diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 00000000..4699790b
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,38 @@
+[profile.dev]
+split-debuginfo = "unpacked"
+opt-level = 1
+debug = 1
+incremental = true
+
+# Optimize dependencies for faster builds
+[profile.dev.package."*"]
+opt-level = 3
+debug = false
+
+# Bevy-specific optimizations
+[profile.dev.package.bevy]
+opt-level = 3
+debug = false
+
+# Fast dev profile for quick iteration
+[profile.dev-fast]
+inherits = "dev"
+opt-level = 0
+debug = false
+incremental = true
+
+[target.x86_64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-Clink-arg=-fuse-ld=lld", "-Ctarget-cpu=native"]
+
+[target.aarch64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-Clink-arg=-fuse-ld=lld", "-Ctarget-cpu=native"]
+
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld.exe"
+rustflags = ["-Ctarget-feature=+crt-static"]
+
+# Build optimizations
+[build]
+jobs = 8
\ No newline at end of file
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index fcad9ff5..2b16cfe2 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -6,74 +6,74 @@ on:
   pull_request:
     branches: [main]
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  # Run cargo test
   test:
     name: Test Suite
     runs-on: ubuntu-latest
-    timeout-minutes: 30
+    timeout-minutes: 25
     steps:
+      - name: Free disk space
+        run: sudo rm -rf /usr/share/dotnet /opt/ghc /usr/local/lib/android /usr/local/share/boost
+      
       - name: Checkout sources
         uses: actions/checkout@v4
-      - name: Cache
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-cargo-test-${{ hashFiles('**/Cargo.toml') }}
-      - name: Install stable toolchain
+      
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+      
+      - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
-      - name: Install Dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - name: Run cargo test
-        run: cargo test
+      
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev clang lld
+      
+      - name: Run tests
+        run: cargo test --workspace
 
-  # Run cargo clippy -- -D warnings
-  clippy_check:
+  clippy:
     name: Clippy
     runs-on: ubuntu-latest
-    timeout-minutes: 30
+    timeout-minutes: 25
     steps:
+      - name: Free disk space
+        run: sudo rm -rf /usr/share/dotnet /opt/ghc /usr/local/lib/android /usr/local/share/boost
+      
       - name: Checkout sources
         uses: actions/checkout@v4
-      - name: Cache
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.toml') }}
-      - name: Install stable toolchain
+      
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+      
+      - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
-      - name: Install Dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
+      
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev clang lld
+      
       - name: Run clippy
-        run: cargo clippy -- -A clippy::upper-case-acronyms -A clippy::new-without-default -A clippy::manual-flatten -A clippy::excessive-precision -A clippy::too-many-arguments
+        run: cargo clippy --workspace -- -A clippy::upper-case-acronyms -A clippy::new-without-default -A clippy::manual-flatten -A clippy::excessive-precision -A clippy::too-many-arguments
 
-  # Run cargo fmt with check flag but allow failures
   format:
     name: Format
     runs-on: ubuntu-latest
-    timeout-minutes: 30
-    continue-on-error: true
+    timeout-minutes: 10
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
-      - name: Install stable toolchain
+      
+      - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt
-      - name: Run cargo fmt
-        run: cargo fmt --all -- --check || true
\ No newline at end of file
+      
+      - name: Check formatting
+        run: cargo fmt --all -- --check
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 879b0c58..bae87929 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,37 @@
-# Ignore build artifacts
-/target
+# Rust build artifacts
+/target/
+**/target/
 Cargo.lock
 
-# Ignore save files
+# IDE and editor settings
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Rust-specific
+**/*.rs.bk
+*.pdb
+
+# Temporary files
+*.tmp
+*.temp
+*.log
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# Application save files
 save.json
\ No newline at end of file
diff --git a/crates/energy/README.md b/crates/energy/README.md
new file mode 100644
index 00000000..33b47b03
--- /dev/null
+++ b/crates/energy/README.md
@@ -0,0 +1,3 @@
+# Energy
+
+Energy conservation, thermodynamics, electromagnetism, and wave mechanics for LP physics simulations.
\ No newline at end of file
diff --git a/crates/energy/src/conservation.rs b/crates/energy/src/conservation.rs
index cfec34c4..47d2d424 100644
--- a/crates/energy/src/conservation.rs
+++ b/crates/energy/src/conservation.rs
@@ -26,10 +26,8 @@ pub struct EnergyQuantity {
 impl EnergyQuantity {
     /// Create a new energy quantity
     pub fn new(value: f32, energy_type: EnergyType, max_capacity: Option<f32>) -> Self {
-        let clamped_value = max_capacity
-            .map(|max| value.min(max))
-            .unwrap_or(value);
-        
+        let clamped_value = max_capacity.map(|max| value.min(max)).unwrap_or(value);
+
         Self {
             value: clamped_value.max(0.0),
             energy_type,
@@ -55,8 +53,8 @@ impl EnergyQuantity {
 /// Energy transaction types for conservation accounting
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Reflect)]
 pub enum TransactionType {
-    Input,   // Energy entering the system
-    Output,  // Energy leaving the system
+    Input,  // Energy entering the system
+    Output, // Energy leaving the system
 }
 
 /// Event for energy transfers between entities
@@ -118,13 +116,13 @@ impl EnergyAccountingLedger {
             TransactionType::Input => self.total_input += transaction.amount,
             TransactionType::Output => self.total_output += transaction.amount,
         }
-        
+
         self.transactions.insert(0, transaction);
         if self.transactions.len() > self.max_history {
             self.transactions.pop();
         }
     }
-    
+
     /// Get the net energy change
     pub fn net_energy_change(&self) -> f32 {
         self.total_input - self.total_output
@@ -150,20 +148,13 @@ impl Default for EnergyConservationTracker {
 }
 
 /// Utility function to verify energy conservation
-pub fn verify_conservation(
-    initial_energy: f32,
-    final_energy: f32,
-    tolerance: f32,
-) -> bool {
+pub fn verify_conservation(initial_energy: f32, final_energy: f32, tolerance: f32) -> bool {
     // First law: Energy cannot be created or destroyed
     (final_energy - initial_energy).abs() <= tolerance
 }
 
 /// Utility function to calculate conversion efficiency
-pub fn conversion_efficiency(
-    energy_input: f32,
-    energy_output: f32,
-) -> f32 {
+pub fn conversion_efficiency(energy_input: f32, energy_output: f32) -> f32 {
     if energy_input > 0.0 {
         (energy_output / energy_input).clamp(0.0, 1.0)
     } else {
@@ -183,11 +174,9 @@ impl Plugin for EnergyConservationPlugin {
             .register_type::<TransactionType>()
             .register_type::<EnergyTransaction>()
             .register_type::<EnergyAccountingLedger>()
-            
             // Add resources
             .init_resource::<EnergyConservationTracker>()
-            
             // Add event channel
             .add_event::<EnergyTransferEvent>();
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/electromagnetism/fields.rs b/crates/energy/src/electromagnetism/fields.rs
index 6a2f0f60..3d72cebb 100644
--- a/crates/energy/src/electromagnetism/fields.rs
+++ b/crates/energy/src/electromagnetism/fields.rs
@@ -124,10 +124,12 @@ pub fn calculate_field_interactions(
     // Electric field interactions
     for (source_entity, source_field) in electric_fields.iter() {
         for (target_entity, target_field) in electric_fields.iter() {
-            if source_entity == target_entity { continue; }
-            
+            if source_entity == target_entity {
+                continue;
+            }
+
             let interaction_strength = source_field.strength() * target_field.strength();
-            
+
             if interaction_strength > f32::EPSILON {
                 field_interaction_events.write(ElectromagneticFieldInteractionEvent {
                     source: source_entity,
@@ -141,10 +143,12 @@ pub fn calculate_field_interactions(
     // Magnetic field interactions (similar logic)
     for (source_entity, source_field) in magnetic_fields.iter() {
         for (target_entity, target_field) in magnetic_fields.iter() {
-            if source_entity == target_entity { continue; }
-            
+            if source_entity == target_entity {
+                continue;
+            }
+
             let interaction_strength = source_field.strength() * target_field.strength();
-            
+
             if interaction_strength > f32::EPSILON {
                 field_interaction_events.write(ElectromagneticFieldInteractionEvent {
                     source: source_entity,
@@ -165,11 +169,9 @@ impl Plugin for ElectromagneticFieldPlugin {
             // Register types for reflection
             .register_type::<ElectricField>()
             .register_type::<MagneticField>()
-            
             // Add electromagnetic field interaction event
             .add_event::<ElectromagneticFieldInteractionEvent>()
-            
             // Add system for field interactions
             .add_systems(Update, calculate_field_interactions);
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/electromagnetism/interactions.rs b/crates/energy/src/electromagnetism/interactions.rs
index e6e6449b..f73a23a6 100644
--- a/crates/energy/src/electromagnetism/interactions.rs
+++ b/crates/energy/src/electromagnetism/interactions.rs
@@ -6,7 +6,7 @@ use bevy::prelude::*;
 const C: f32 = 299_792_458.0;
 
 /// Represents an electromagnetic wave component
-#[derive(Debug, Component)]
+#[derive(Debug, Component, Reflect)]
 pub struct ElectromagneticWave {
     /// Wave frequency in Hertz
     pub frequency: f32,
@@ -74,7 +74,7 @@ impl ElectromagneticWave {
 }
 
 /// Material electromagnetic properties component
-#[derive(Debug, Clone, Copy, Component)]
+#[derive(Debug, Clone, Copy, Component, Reflect)]
 pub struct MaterialProperties {
     /// Electric permittivity
     pub permittivity: f32,
@@ -118,4 +118,4 @@ impl MaterialProperties {
         // v = c/n
         C / self.refractive_index()
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/electromagnetism/mod.rs b/crates/energy/src/electromagnetism/mod.rs
index 5a198d98..c9f04da7 100644
--- a/crates/energy/src/electromagnetism/mod.rs
+++ b/crates/energy/src/electromagnetism/mod.rs
@@ -1,12 +1,25 @@
 pub mod fields;
 pub mod interactions;
 
+use bevy::prelude::*;
+
+pub struct ElectromagnetismPlugin;
+
+impl Plugin for ElectromagnetismPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<fields::ElectricField>()
+            .register_type::<fields::MagneticField>()
+            .register_type::<interactions::ElectromagneticWave>()
+            .register_type::<interactions::MaterialProperties>()
+            .add_event::<fields::ElectromagneticFieldInteractionEvent>()
+            .add_systems(Update, fields::calculate_field_interactions);
+    }
+}
+
 /// The electromagnetism prelude.
 ///
 /// This includes the most common types for electromagnetic systems.
 pub mod prelude {
     pub use crate::electromagnetism::fields::{ElectricField, MagneticField};
-    pub use crate::electromagnetism::interactions::{
-        ElectromagneticWave, MaterialProperties
-    };
-}
\ No newline at end of file
+    pub use crate::electromagnetism::interactions::{ElectromagneticWave, MaterialProperties};
+}
diff --git a/crates/energy/src/lib.rs b/crates/energy/src/lib.rs
index 1d458866..6de90d4a 100644
--- a/crates/energy/src/lib.rs
+++ b/crates/energy/src/lib.rs
@@ -1,11 +1,15 @@
-use bevy::prelude::*;
-
 pub mod conservation;
-pub mod thermodynamics;
 pub mod electromagnetism;
+pub mod thermodynamics;
 pub mod waves;
 
-// Add these new energy system related definitions
+use bevy::prelude::*;
+
+pub use conservation::EnergyConservationPlugin;
+pub use electromagnetism::ElectromagnetismPlugin;
+pub use thermodynamics::ThermodynamicsPlugin;
+pub use waves::WavesPlugin;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Reflect)]
 pub enum EnergyType {
     Generic,
@@ -28,33 +32,37 @@ pub enum EnergyTransferError {
 /// Core trait for all energy-based systems in the simulation
 /// This complements the existing EnergyQuantity component
 pub trait EnergySystem {
-    // Core energy tracking 
+    // Core energy tracking
     fn total_energy(&self) -> f32;
-    
+
     // Energy transfer with entropy consideration
     fn transfer_energy(&mut self, energy: f32) -> Result<f32, EnergyTransferError> {
         // Default implementation could track basic conservation
         Ok(energy)
     }
-    
+
     // Transformation efficiency
     fn transformation_efficiency(&self) -> f32 {
         1.0 // Default full efficiency
     }
-    
+
     // Entropy generation during energy transfer
     fn entropy_generation(&self, _energy_transfer: f32) -> f32 {
         0.0 // Default no entropy generation
     }
-    
+
     // Energy type for this system
     fn energy_type(&self) -> EnergyType {
         EnergyType::Generic
     }
-    
+
     // Create an EnergyTransaction for the ledger (optional)
-    fn create_transaction(&self, amount: f32, source: Option<Entity>, 
-                         destination: Option<Entity>) -> conservation::EnergyTransaction {
+    fn create_transaction(
+        &self,
+        amount: f32,
+        source: Option<Entity>,
+        destination: Option<Entity>,
+    ) -> conservation::EnergyTransaction {
         conservation::EnergyTransaction {
             transaction_type: if amount > 0.0 {
                 conservation::TransactionType::Input
@@ -69,25 +77,30 @@ pub trait EnergySystem {
     }
 }
 
-/// Root energy prelude that re-exports all important items
+/// Main plugin for all energy-related systems
+#[derive(Default)]
+pub struct EnergyPlugin;
+
+impl Plugin for EnergyPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<EnergyType>()
+            .add_plugins(EnergyConservationPlugin)
+            .add_plugins(ThermodynamicsPlugin)
+            .add_plugins(ElectromagnetismPlugin)
+            .add_plugins(WavesPlugin);
+    }
+}
+
 pub mod prelude {
-    // Add the new trait and types to the prelude
-    pub use super::{EnergySystem, EnergyTransferError, EnergyType};
-    
-    // Re-export from conservation
+    pub use super::{EnergySystem, EnergyTransferError};
+
     pub use crate::conservation::{
-        EnergyQuantity, 
-        EnergyTransferEvent, 
-        EnergyAccountingLedger, 
-        TransactionType, 
-        EnergyConservationTracker,
-        verify_conservation, 
-        conversion_efficiency,
-        EnergyConservationPlugin
+        conversion_efficiency, verify_conservation, EnergyAccountingLedger,
+        EnergyConservationPlugin, EnergyConservationTracker, EnergyQuantity, EnergyTransaction,
+        EnergyTransferEvent, EnergyType, TransactionType,
     };
-    
-    // Re-export from submodules
+
+    pub use crate::electromagnetism::prelude::*;
     pub use crate::thermodynamics::prelude::*;
     pub use crate::waves::prelude::*;
-    pub use crate::electromagnetism::prelude::*;
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/thermodynamics/entropy.rs b/crates/energy/src/thermodynamics/entropy.rs
index 1314e5ce..4d7c9eba 100644
--- a/crates/energy/src/thermodynamics/entropy.rs
+++ b/crates/energy/src/thermodynamics/entropy.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 /// Entropy component for thermodynamic systems
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 pub struct Entropy {
     /// Entropy in J/K
     pub value: f32,
@@ -16,7 +16,7 @@ impl Entropy {
 }
 
 /// Process reversibility characteristic
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Reflect)]
 pub enum Reversibility {
     Reversible,
     Irreversible,
@@ -34,14 +34,14 @@ pub fn entropy_change_heat_transfer(heat_transferred: f32, temperature: f32) ->
 
 /// Calculate entropy change for irreversible processes
 pub fn entropy_change_irreversible(
-    energy_transferred: f32,    // Energy transferred in process (J)
-    source_temperature: f32,    // Temperature of source (K)
-    sink_temperature: f32,      // Temperature of sink (K)
+    energy_transferred: f32, // Energy transferred in process (J)
+    source_temperature: f32, // Temperature of source (K)
+    sink_temperature: f32,   // Temperature of sink (K)
 ) -> f32 {
     // For irreversible processes, total entropy change is positive
     // ΔS = Q/Tcold - Q/Thot
     if source_temperature > 0.0 && sink_temperature > 0.0 {
-        energy_transferred * (1.0/sink_temperature - 1.0/source_temperature)
+        energy_transferred * (1.0 / sink_temperature - 1.0 / source_temperature)
     } else {
         0.0
     }
@@ -54,9 +54,6 @@ pub fn is_valid_process(total_entropy_change: f32) -> bool {
 }
 
 /// Calculate total entropy change of a system and its surroundings
-pub fn total_entropy_change(
-    system_entropy_change: f32,
-    surroundings_entropy_change: f32,
-) -> f32 {
+pub fn total_entropy_change(system_entropy_change: f32, surroundings_entropy_change: f32) -> f32 {
     system_entropy_change + surroundings_entropy_change
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/thermodynamics/equilibrium.rs b/crates/energy/src/thermodynamics/equilibrium.rs
index e0fd21a6..7e703ea5 100644
--- a/crates/energy/src/thermodynamics/equilibrium.rs
+++ b/crates/energy/src/thermodynamics/equilibrium.rs
@@ -1,13 +1,15 @@
 use bevy::prelude::*;
 
 /// Component marking systems in thermal equilibrium
-#[derive(Component, Debug)]
+#[derive(Component, Debug, Reflect)]
 pub struct ThermalEquilibrium {
     pub connected_entities: Vec<Entity>,
 }
 
-/// Component for phase state of matter that will use the matter crate later once implemented
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+/// Component for phase state of matter that will use the matter crate later once implemented, soon once PBMPM will be in place
+/// and the matter crate is implemented
+/// This is a placeholder for the actual phase state representation
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Reflect)]
 pub enum PhaseState {
     Solid,
     Liquid,
@@ -16,7 +18,7 @@ pub enum PhaseState {
 }
 
 /// Weighted equilibrium parameters
-#[derive(Component, Debug, Clone, Copy)]  
+#[derive(Component, Debug, Clone, Copy)]
 pub struct ThermalProperties {
     pub thermal_mass: f32,
 }
@@ -27,26 +29,26 @@ pub fn is_in_equilibrium(
     temp_b: f32,
     props_a: &ThermalProperties,
     props_b: &ThermalProperties,
-    tolerance: f32
+    tolerance: f32,
 ) -> bool {
     // Weighted equilibrium considers both temperature and thermal properties
-    let weighted_diff = (temp_a - temp_b).abs() /
-        (1.0 + (props_a.thermal_mass * props_b.thermal_mass).sqrt());
-    weighted_diff <= tolerance  
+    let weighted_diff =
+        (temp_a - temp_b).abs() / (1.0 + (props_a.thermal_mass * props_b.thermal_mass).sqrt());
+    weighted_diff <= tolerance
 }
 
 pub fn equilibrium_time_estimate(
     temp_diff: f32, // Initial temperature difference
     props_a: &ThermalProperties,
     props_b: &ThermalProperties,
-    heat_transfer_rate: f32, // Rate of heat transfer (W)  
+    heat_transfer_rate: f32, // Rate of heat transfer (W)
 ) -> f32 {
     // More sophisticated estimate considering thermal masses
     let combined_thermal_mass = props_a.thermal_mass + props_b.thermal_mass;
-    if heat_transfer_rate > 0.0 { 
+    if heat_transfer_rate > 0.0 {
         // Weighted by combined thermal mass
         combined_thermal_mass * temp_diff / heat_transfer_rate
     } else {
         f32::INFINITY
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/thermodynamics/mod.rs b/crates/energy/src/thermodynamics/mod.rs
index f23ebfe8..bfccdc50 100644
--- a/crates/energy/src/thermodynamics/mod.rs
+++ b/crates/energy/src/thermodynamics/mod.rs
@@ -2,8 +2,34 @@ pub mod entropy;
 pub mod equilibrium;
 pub mod thermal;
 
+use bevy::prelude::*;
+
+pub struct ThermodynamicsPlugin;
+
+impl Plugin for ThermodynamicsPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<thermal::Temperature>()
+            .register_type::<thermal::ThermalConductivity>()
+            .register_type::<thermal::ThermalDiffusivity>()
+            .register_type::<entropy::Entropy>()
+            .register_type::<entropy::Reversibility>()
+            .register_type::<equilibrium::ThermalEquilibrium>()
+            .register_type::<equilibrium::PhaseState>()
+            .add_event::<thermal::ThermalTransferEvent>()
+            .add_systems(Update, thermal::calculate_thermal_transfer);
+    }
+}
+
 pub mod prelude {
-    pub use super::thermal::{Temperature, ThermalConductivity, ThermalDiffusivity, thermal_utils::heat_conduction};
-    pub use super::entropy::{Entropy, Reversibility, entropy_change_heat_transfer, entropy_change_irreversible, is_valid_process, total_entropy_change};
-    pub use super::equilibrium::{ThermalEquilibrium, PhaseState, ThermalProperties, is_in_equilibrium, equilibrium_time_estimate};
-}
\ No newline at end of file
+    pub use super::entropy::{
+        entropy_change_heat_transfer, entropy_change_irreversible, is_valid_process,
+        total_entropy_change, Entropy, Reversibility,
+    };
+    pub use super::equilibrium::{
+        equilibrium_time_estimate, is_in_equilibrium, PhaseState, ThermalEquilibrium,
+        ThermalProperties,
+    };
+    pub use super::thermal::{
+        thermal_utils::heat_conduction, Temperature, ThermalConductivity, ThermalDiffusivity,
+    };
+}
diff --git a/crates/energy/src/thermodynamics/thermal.rs b/crates/energy/src/thermodynamics/thermal.rs
index 6329bcc1..c28e8105 100644
--- a/crates/energy/src/thermodynamics/thermal.rs
+++ b/crates/energy/src/thermodynamics/thermal.rs
@@ -87,13 +87,16 @@ pub fn calculate_thermal_transfer(
 ) {
     // Use query.iter_combinations() to efficiently compare all entities
     let mut combinations = query.iter_combinations();
-    while let Some([(entity1, temp1, conduct1), (entity2, temp2, conduct2)]) = combinations.fetch_next() {
+    while let Some([(entity1, temp1, conduct1), (entity2, temp2, conduct2)]) =
+        combinations.fetch_next()
+    {
         let temp_diff: f32 = temp1.value - temp2.value;
         let area: f32 = 1.0; // Placeholder
         let distance: f32 = 1.0; // Placeholder
-        
-        let heat_flow: f32 = (conduct1.value + conduct2.value) / 2.0 * area * temp_diff / distance.max(f32::EPSILON);
-        
+
+        let heat_flow: f32 =
+            (conduct1.value + conduct2.value) / 2.0 * area * temp_diff / distance.max(f32::EPSILON);
+
         if heat_flow.abs() > f32::EPSILON {
             thermal_transfer_events.write(ThermalTransferEvent {
                 source: if heat_flow > 0.0 { entity1 } else { entity2 },
@@ -145,11 +148,9 @@ impl Plugin for ThermalSystemPlugin {
             .register_type::<ThermalConductivity>()
             .register_type::<ThermalDiffusivity>()
             .register_type::<Emissivity>()
-            
             // Add thermal transfer event channel
             .add_event::<ThermalTransferEvent>()
-            
             // Add system for thermal calculations
             .add_systems(Update, calculate_thermal_transfer);
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/waves/mod.rs b/crates/energy/src/waves/mod.rs
index 80789792..c449b045 100644
--- a/crates/energy/src/waves/mod.rs
+++ b/crates/energy/src/waves/mod.rs
@@ -3,22 +3,41 @@ pub mod propagation;
 pub mod superposition;
 pub mod wave_equation;
 
+use bevy::prelude::*;
+
+pub struct WavesPlugin;
+
+impl Plugin for WavesPlugin {
+    fn build(&self, app: &mut App) {
+        // Register wave components
+        app.register_type::<oscillation::WaveParameters>()
+            .register_type::<propagation::WavePosition>()
+            .register_type::<propagation::WaveType>()
+            .register_type::<propagation::WaveCenterMarker>()
+            .register_type::<superposition::StandingWaveMarker>()
+            .register_type::<wave_equation::WaveEquationComponent>()
+            .add_event::<oscillation::WaveGenerationEvent>()
+            .add_systems(Update, propagation::update_wave_displacements)
+            .add_systems(Update, superposition::update_standing_waves)
+            .add_systems(Update, wave_equation::update_wave_equation);
+    }
+}
+
 /// The waves prelude.
 ///
 /// This includes the most common types for wave systems.
 pub mod prelude {
     pub use crate::waves::oscillation::{
-        WaveParameters, wave_number, angular_frequency, damping_from_half_life
+        angular_frequency, damping_from_half_life, wave_number, WaveParameters,
     };
     pub use crate::waves::propagation::{
-        WavePosition, WaveType, WaveCenterMarker, 
-        solve_wave, solve_radial_wave, update_wave_displacements, create_linear_wave
+        create_linear_wave, solve_radial_wave, solve_wave, update_wave_displacements,
+        WaveCenterMarker, WavePosition, WaveType,
     };
     pub use crate::waves::superposition::{
-        StandingWaveMarker, solve_standing_wave, 
-        update_standing_waves, create_standing_wave
+        create_standing_wave, solve_standing_wave, update_standing_waves, StandingWaveMarker,
     };
     pub use crate::waves::wave_equation::{
-        WaveEquation2D, WaveEquationComponent, update_wave_equation
+        update_wave_equation, WaveEquation2D, WaveEquationComponent,
     };
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/waves/oscillation.rs b/crates/energy/src/waves/oscillation.rs
index a71817c7..a23414e6 100644
--- a/crates/energy/src/waves/oscillation.rs
+++ b/crates/energy/src/waves/oscillation.rs
@@ -122,15 +122,22 @@ pub struct WaveGenerationEvent {
 }
 
 /// System for wave parameter validation
-pub fn validate_wave_parameters(
-    mut wave_generation_events: EventReader<WaveGenerationEvent>,
-) {
+pub fn validate_wave_parameters(mut wave_generation_events: EventReader<WaveGenerationEvent>) {
     for event in wave_generation_events.read() {
         // Validate wave parameters
-        assert!(event.parameters.amplitude >= 0.0, "Wave amplitude must be non-negative");
-        assert!(event.parameters.wavelength > 0.0, "Wavelength must be positive");
-        assert!(event.parameters.speed >= 0.0, "Wave speed must be non-negative");
-        
+        assert!(
+            event.parameters.amplitude >= 0.0,
+            "Wave amplitude must be non-negative"
+        );
+        assert!(
+            event.parameters.wavelength > 0.0,
+            "Wavelength must be positive"
+        );
+        assert!(
+            event.parameters.speed >= 0.0,
+            "Wave speed must be non-negative"
+        );
+
         // Optional: Log or handle invalid parameters
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/waves/propagation.rs b/crates/energy/src/waves/propagation.rs
index 48ebd9a9..b7e979be 100644
--- a/crates/energy/src/waves/propagation.rs
+++ b/crates/energy/src/waves/propagation.rs
@@ -1,5 +1,5 @@
+use super::oscillation::{angular_frequency, wave_number, WaveParameters};
 use bevy::prelude::*;
-use super::oscillation::{WaveParameters, wave_number, angular_frequency};
 
 // Calculate modified angular frequency with dispersion
 #[inline]
@@ -18,25 +18,25 @@ pub fn dispersive_angular_frequency(params: &WaveParameters, k: f32) -> f32 {
 }
 
 /// Component to store position for wave calculations
-#[derive(Component, Debug, Clone)]
+#[derive(Component, Debug, Clone, Reflect)]
 pub struct WavePosition(pub Vec2);
 
 impl WavePosition {
     pub fn new(position: Vec2) -> Self {
         Self(position)
     }
-    
+
     pub fn from_xy(x: f32, y: f32) -> Self {
         Self(Vec2::new(x, y))
     }
-    
+
     pub fn from_x(x: f32) -> Self {
         Self(Vec2::new(x, 0.0))
     }
 }
 
 /// Wave type marker component
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Reflect)]
 pub enum WaveType {
     Traveling,
     Radial,
@@ -44,26 +44,26 @@ pub enum WaveType {
 }
 
 // Marker component for wave centers (for radial waves)
-#[derive(Component)]
+#[derive(Component, Reflect)]
 pub struct WaveCenterMarker;
 
 #[inline]
 pub fn solve_wave(params: &WaveParameters, position: Vec2, time: f32) -> f32 {
     let k = wave_number(params.wavelength);
     let omega = dispersive_angular_frequency(params, k);
-    
+
     let k_vec = params.direction.normalize() * k;
     let dot_product = k_vec.dot(position);
-    
+
     // Calculate the phase argument for the wave function
     let phase = dot_product - omega * time + params.phase;
-    
+
     // Apply damping over time
     let damping_factor = (-params.damping * time).exp();
-    
+
     // Use sine as the wave function (can be generalized later)
     let wave_function = phase.sin();
-    
+
     params.amplitude * damping_factor * wave_function
 }
 
@@ -71,55 +71,63 @@ pub fn solve_wave(params: &WaveParameters, position: Vec2, time: f32) -> f32 {
 pub fn solve_radial_wave(params: &WaveParameters, center: Vec2, position: Vec2, time: f32) -> f32 {
     let k = wave_number(params.wavelength);
     let omega = dispersive_angular_frequency(params, k);
-    
+
     // Calculate vector from center to position
     let displacement = position - center;
     let distance = displacement.length();
-    
+
     // Calculate spatial decay (amplitude decreases with distance)
     let spatial_falloff = if distance > 0.001 {
         1.0 / distance.sqrt()
     } else {
         1.0
     };
-    
+
     // Calculate the phase argument, potentially allowing for direction-dependent effects
     let phase = k * distance - omega * time + params.phase;
-    
+
     // Apply damping over time
     let damping_factor = (-params.damping * time).exp();
-    
+
     // Calculate the final wave displacement
     params.amplitude * spatial_falloff * damping_factor * phase.sin()
 }
 
 pub fn update_wave_displacements(
     time: Res<Time>,
-    mut query: Query<(&mut Transform, &WaveParameters, &WavePosition, Option<&WaveType>)>,
+    mut query: Query<(
+        &mut Transform,
+        &WaveParameters,
+        &WavePosition,
+        Option<&WaveType>,
+    )>,
     wave_centers: Query<(&Transform, &WaveCenterMarker)>,
 ) {
     let t = time.elapsed_secs();
-    
+
     for (mut transform, params, position, wave_type) in query.iter_mut() {
         let displacement = match wave_type {
             Some(WaveType::Radial) => {
                 // Find the nearest wave center
-                let center = wave_centers.iter()
+                let center = wave_centers
+                    .iter()
                     .map(|(t, _)| t.translation.truncate())
                     .min_by(|a, b| {
                         let dist_a = a.distance(position.0);
                         let dist_b = b.distance(position.0);
-                        dist_a.partial_cmp(&dist_b).unwrap_or(std::cmp::Ordering::Equal)
+                        dist_a
+                            .partial_cmp(&dist_b)
+                            .unwrap_or(std::cmp::Ordering::Equal)
                     })
                     .unwrap_or(Vec2::ZERO);
-                    
+
                 solve_radial_wave(params, center, position.0, t)
-            },
+            }
             // Standing waves should be handled by the superposition system
-            Some(WaveType::Standing) => 0.0, 
+            Some(WaveType::Standing) => 0.0,
             _ => solve_wave(params, position.0, t),
         };
-        
+
         let displacement_vec = params.displacement_axis.normalize() * displacement;
         transform.translation.x += displacement_vec.x;
         transform.translation.y += displacement_vec.y;
@@ -128,14 +136,14 @@ pub fn update_wave_displacements(
 
 // Helper functions for common wave patterns
 pub fn create_linear_wave(
-    amplitude: f32, 
-    wavelength: f32, 
+    amplitude: f32,
+    wavelength: f32,
     speed: f32,
-    phase: f32, 
-    direction: Vec2, 
+    phase: f32,
+    direction: Vec2,
     displacement_axis: Vec2,
     damping: f32,
-    dispersion_factor: f32
+    dispersion_factor: f32,
 ) -> WaveParameters {
     WaveParameters {
         amplitude,
@@ -147,4 +155,4 @@ pub fn create_linear_wave(
         damping,
         dispersion_factor,
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/waves/superposition.rs b/crates/energy/src/waves/superposition.rs
index 519f21a0..b60080e6 100644
--- a/crates/energy/src/waves/superposition.rs
+++ b/crates/energy/src/waves/superposition.rs
@@ -1,25 +1,25 @@
-use bevy::prelude::*;
-use super::oscillation::{WaveParameters, wave_number, angular_frequency};
+use super::oscillation::{angular_frequency, wave_number, WaveParameters};
 use super::propagation::WavePosition;
+use bevy::prelude::*;
 
 #[inline]
 pub fn solve_standing_wave(
-    params: &WaveParameters, 
-    position: Vec2, 
+    params: &WaveParameters,
+    position: Vec2,
     time: f32,
-    interference_fn: Option<impl Fn(f32) -> f32>
+    interference_fn: Option<impl Fn(f32) -> f32>,
 ) -> f32 {
     let k = wave_number(params.wavelength);
     let omega = angular_frequency(params.speed, k);
-    
+
     let direction = params.direction.normalize();
     let spatial_term = (k * direction.dot(position) + params.phase).sin();
     let temporal_term = (omega * time).cos();
-    
+
     let damping_factor = (-params.damping * time).exp();
-    
+
     let base_wave = params.amplitude * damping_factor * spatial_term * temporal_term;
-    
+
     interference_fn
         .map(|f| base_wave * f(time))
         .unwrap_or(base_wave)
@@ -35,7 +35,7 @@ pub fn update_standing_waves(
     mut query: Query<(&mut Transform, &WaveParameters, &WavePosition), With<StandingWaveMarker>>,
 ) {
     let t = time.elapsed_secs();
-    
+
     for (mut transform, params, position) in query.iter_mut() {
         let displacement = solve_standing_wave(params, position.0, t, None::<fn(f32) -> f32>);
         let displacement_vec = params.displacement_axis.normalize() * displacement;
@@ -57,8 +57,7 @@ pub fn handle_wave_modifications(
     mut wave_mod_events: EventReader<StandingWaveModificationEvent>,
 ) {
     for event in wave_mod_events.read() {
-        commands.entity(event.entity)
-            .insert(event.new_parameters.clone());
+        commands.entity(event.entity).insert(event.new_parameters);
     }
 }
 
@@ -71,7 +70,7 @@ pub fn create_standing_wave(
     direction: Vec2,
     displacement_axis: Vec2,
     damping: f32,
-    dispersion_factor: f32
+    dispersion_factor: f32,
 ) -> WaveParameters {
     WaveParameters {
         amplitude,
@@ -90,12 +89,8 @@ pub struct StandingWavePlugin;
 
 impl Plugin for StandingWavePlugin {
     fn build(&self, app: &mut App) {
-        app
-            .register_type::<StandingWaveMarker>()
+        app.register_type::<StandingWaveMarker>()
             .add_event::<StandingWaveModificationEvent>()
-            .add_systems(Update, (
-                update_standing_waves,
-                handle_wave_modifications
-            ));
+            .add_systems(Update, (update_standing_waves, handle_wave_modifications));
     }
-}
\ No newline at end of file
+}
diff --git a/crates/energy/src/waves/wave_equation.rs b/crates/energy/src/waves/wave_equation.rs
index 3517c789..d5c2a974 100644
--- a/crates/energy/src/waves/wave_equation.rs
+++ b/crates/energy/src/waves/wave_equation.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 /// 2D Wave equation solver (∂²u/∂t² = c²(∂²u/∂x² + ∂²u/∂y²))
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Reflect)]
 pub struct WaveEquation2D {
     /// Grid dimensions
     pub nx: usize,
@@ -28,24 +28,31 @@ impl WaveEquation2D {
         // Initialize with zero arrays
         let u_current = vec![0.0; nx * ny];
         let u_previous = vec![0.0; nx * ny];
-        
+
         // Pre-compute coefficient for wave equation
         let laplacian_x_coeff = (c * dt / dx).powi(2);
         let laplacian_y_coeff = (c * dt / dy).powi(2);
-        
+
         Self {
-            nx, ny, c, dx, dy, dt, u_current, u_previous,
-            laplacian_x_coeff, laplacian_y_coeff
+            nx,
+            ny,
+            c,
+            dx,
+            dy,
+            dt,
+            u_current,
+            u_previous,
+            laplacian_x_coeff,
+            laplacian_y_coeff,
         }
     }
-    
+
     /// Check stability (Courant condition)
     pub fn is_stable(&self) -> bool {
-        let courant = self.c * self.dt * 
-            ((1.0/self.dx).powi(2) + (1.0/self.dy).powi(2)).sqrt();
+        let courant = self.c * self.dt * ((1.0 / self.dx).powi(2) + (1.0 / self.dy).powi(2)).sqrt();
         courant <= 1.0
     }
-    
+
     /// Set initial conditions
     pub fn set_initial_displacement(&mut self, u0: Vec<f32>) {
         if u0.len() == self.nx * self.ny {
@@ -53,77 +60,76 @@ impl WaveEquation2D {
             self.u_previous = u0;
         }
     }
-    
+
     /// Get value at specific grid point
     /// Uses row-major layout (y*nx+x) for better cache locality during inner loop iteration
     #[inline]
     fn get(&self, grid: &[f32], x: usize, y: usize) -> f32 {
         grid[y * self.nx + x]
     }
-    
+
     /// Set value at specific grid point
     /// Uses row-major layout (y*nx+x) for better cache locality during inner loop iteration
     #[inline]
-    fn set(&mut self, grid: &mut Vec<f32>, x: usize, y: usize, value: f32) {
+    fn set(&mut self, grid: &mut [f32], x: usize, y: usize, value: f32) {
         grid[y * self.nx + x] = value;
     }
-    
+
     /// Solve one time step using finite difference method
     pub fn step(&mut self) {
         // Create next state
         let mut u_next = vec![0.0; self.nx * self.ny];
-        
+
         // Use pre-computed coefficients
         let cx = self.laplacian_x_coeff;
         let cy = self.laplacian_y_coeff;
-        
+
         // Apply wave equation to interior points
         // Process in chunks for better cache usage
         const CHUNK_SIZE: usize = 32;
-        
+
         // Optimize memory access patterns by processing in blocks
-        for j_chunk in 1..((self.ny-1+CHUNK_SIZE-1)/CHUNK_SIZE) {
-            let j_start = (j_chunk-1)*CHUNK_SIZE + 1;
-            let j_end = (j_start + CHUNK_SIZE - 1).min(self.ny-2);
-            
-            for i_chunk in 1..((self.nx-1+CHUNK_SIZE-1)/CHUNK_SIZE) {
-                let i_start = (i_chunk-1)*CHUNK_SIZE + 1;
-                let i_end = (i_start + CHUNK_SIZE - 1).min(self.nx-2);
-                
+        for j_chunk in 1..((self.ny - 1).div_ceil(CHUNK_SIZE)) {
+            let j_start = (j_chunk - 1) * CHUNK_SIZE + 1;
+            let j_end = (j_start + CHUNK_SIZE - 1).min(self.ny - 2);
+
+            for i_chunk in 1..((self.nx - 1).div_ceil(CHUNK_SIZE)) {
+                let i_start = (i_chunk - 1) * CHUNK_SIZE + 1;
+                let i_end = (i_start + CHUNK_SIZE - 1).min(self.nx - 2);
+
                 for j in j_start..=j_end {
                     for i in i_start..=i_end {
                         // Finite difference formula for 2D wave equation
-                        let laplacian_x = 
-                            self.get(&self.u_current, i+1, j) - 
-                            2.0 * self.get(&self.u_current, i, j) + 
-                            self.get(&self.u_current, i-1, j);
-                        
-                        let laplacian_y = 
-                            self.get(&self.u_current, i, j+1) - 
-                            2.0 * self.get(&self.u_current, i, j) + 
-                            self.get(&self.u_current, i, j-1);
-                        
-                        let next_value = 2.0 * self.get(&self.u_current, i, j) - 
-                                        self.get(&self.u_previous, i, j) + 
-                                        cx * laplacian_x + cy * laplacian_y;
-                        
+                        let laplacian_x = self.get(&self.u_current, i + 1, j)
+                            - 2.0 * self.get(&self.u_current, i, j)
+                            + self.get(&self.u_current, i - 1, j);
+
+                        let laplacian_y = self.get(&self.u_current, i, j + 1)
+                            - 2.0 * self.get(&self.u_current, i, j)
+                            + self.get(&self.u_current, i, j - 1);
+
+                        let next_value = 2.0 * self.get(&self.u_current, i, j)
+                            - self.get(&self.u_previous, i, j)
+                            + cx * laplacian_x
+                            + cy * laplacian_y;
+
                         self.set(&mut u_next, i, j, next_value);
                     }
                 }
             }
         }
-        
+
         // Apply fixed boundary conditions (u=0 at boundary)
         for i in 0..self.nx {
             self.set(&mut u_next, i, 0, 0.0);
-            self.set(&mut u_next, i, self.ny-1, 0.0);
+            self.set(&mut u_next, i, self.ny - 1, 0.0);
         }
-        
+
         for j in 0..self.ny {
             self.set(&mut u_next, 0, j, 0.0);
-            self.set(&mut u_next, self.nx-1, j, 0.0);
+            self.set(&mut u_next, self.nx - 1, j, 0.0);
         }
-        
+
         // Update states
         self.u_previous = self.u_current.clone();
         self.u_current = u_next;
@@ -131,16 +137,14 @@ impl WaveEquation2D {
 }
 
 /// Component wrapper for the wave equation
-#[derive(Component)]
+#[derive(Component, Reflect)]
 pub struct WaveEquationComponent {
     pub solver: WaveEquation2D,
 }
 
 /// System to update wave equation simulation
-pub fn update_wave_equation(
-    mut query: Query<&mut WaveEquationComponent>,
-) {
+pub fn update_wave_equation(mut query: Query<&mut WaveEquationComponent>) {
     for mut component in query.iter_mut() {
         component.solver.step();
     }
-}
\ No newline at end of file
+}
diff --git a/crates/forces/README.md b/crates/forces/README.md
new file mode 100644
index 00000000..af572764
--- /dev/null
+++ b/crates/forces/README.md
@@ -0,0 +1,3 @@
+# Forces
+
+Gravitational mechanics and Newton's laws for physics-based force systems.
\ No newline at end of file
diff --git a/crates/forces/src/core/gravity.rs b/crates/forces/src/core/gravity.rs
index d47ebea7..79113df1 100644
--- a/crates/forces/src/core/gravity.rs
+++ b/crates/forces/src/core/gravity.rs
@@ -1,34 +1,9 @@
 use super::newton_laws::{AppliedForce, Mass};
 use bevy::prelude::*;
 
-/// A trait for computing the squared norm of a vector efficiently
-trait Norm {
-    type Output;
-    fn norm_squared(self) -> Self::Output;
-}
-
-impl Norm for Vec3 {
-    type Output = f32;
-    #[inline]
-    fn norm_squared(self) -> f32 {
-        self.length_squared()
-    }
-}
-
 /// Modified gravitational constant for simulation scale
 pub const GRAVITATIONAL_CONSTANT: f32 = 0.1;
 
-/// Calculate softened gravitational acceleration between two bodies
-#[inline]
-fn calculate_softened_acceleration(direction: Vec3, mass: f32, softening_squared: f32) -> Vec3 {
-    let distance_squared = direction.norm_squared();
-    // Apply softening to prevent singularities
-    let softened_distance_squared = distance_squared + softening_squared;
-    let force_magnitude = GRAVITATIONAL_CONSTANT * mass / softened_distance_squared;
-
-    direction.normalize() * force_magnitude
-}
-
 /// Resource for gravity simulation parameters
 #[derive(Resource, Clone, Debug)]
 pub struct GravityParams {
@@ -57,29 +32,28 @@ impl Default for UniformGravity {
 }
 
 /// Component for entities affected by gravity
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 pub struct GravityAffected;
 
 /// Marker component for gravity field measurement points
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 pub struct GravityFieldMarker;
 
 /// Component for objects that generate gravitational attraction
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 pub struct GravitySource;
 
 /// Marker for bodies with significant mass
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 pub struct MassiveBody;
 
 // Spatial partitioning structures for Barnes-Hut algorithm
 mod spatial {
-    use bevy::prelude::*; //TODO: Redundant and may need to make this a clearer section instead
+    use bevy::prelude::*;
 
     const MAX_DEPTH: usize = 8;
     const MAX_BODIES_PER_NODE: usize = 8;
 
-    /// 2D axis-aligned bounding box
     #[derive(Clone, Debug)]
     pub struct AABB {
         pub center: Vec2,
@@ -105,8 +79,6 @@ mod spatial {
 
         pub fn get_quadrant_aabb(&self, quadrant: usize) -> AABB {
             let quarter_size = self.half_size * 0.5;
-            // x-offset: negative for left (quadrants 0,2), positive for right (quadrants 1,3)
-            // y-offset: positive for top (quadrants 0,1), negative for bottom (quadrants 2,3)
             let x_sign = if (quadrant & 1) == 0 { -1.0 } else { 1.0 };
             let y_sign = if (quadrant & 2) == 0 { 1.0 } else { -1.0 };
 
@@ -117,7 +89,6 @@ mod spatial {
         }
     }
 
-    /// Mass properties for Barnes-Hut approximation
     #[derive(Clone, Debug)]
     pub struct MassProperties {
         pub total_mass: f32,
@@ -142,13 +113,12 @@ mod spatial {
         }
     }
 
-    /// Node in the quadtree
     #[derive(Debug)]
     pub struct QuadtreeNode {
         pub aabb: AABB,
         pub depth: usize,
         pub mass_properties: MassProperties,
-        pub bodies: Vec<(Entity, Vec3, f32)>, // Entity, position, mass
+        pub bodies: Vec<(Entity, Vec3, f32)>,
         pub children: [Option<Box<QuadtreeNode>>; 4],
     }
 
@@ -176,7 +146,6 @@ mod spatial {
         }
 
         pub fn insert(&mut self, entity: Entity, position: Vec3, mass: f32) {
-            let pos_2d = Vec2::new(position.x, position.y);
             self.mass_properties.add_body(position, mass);
 
             if self.depth >= MAX_DEPTH
@@ -196,21 +165,20 @@ mod spatial {
 
                 let existing_bodies = std::mem::take(&mut self.bodies);
                 for (e, p, m) in existing_bodies {
-                    let q = self.aabb.get_quadrant(Vec2::new(p.x, p.y));
+                    let q = self.aabb.get_quadrant(p.truncate());
                     if let Some(child) = &mut self.children[q] {
                         child.insert(e, p, m);
                     }
                 }
             }
 
-            let quadrant = self.aabb.get_quadrant(pos_2d);
+            let quadrant = self.aabb.get_quadrant(position.truncate());
             if let Some(child) = &mut self.children[quadrant] {
                 child.insert(entity, position, mass);
             }
         }
     }
 
-    /// Main quadtree structure
     #[derive(Debug)]
     pub struct Quadtree {
         pub root: QuadtreeNode,
@@ -228,7 +196,6 @@ mod spatial {
                 return Self::new(AABB::new(Vec2::ZERO, Vec2::new(1000.0, 1000.0)));
             }
 
-            // Find bounds
             let mut min_x = f32::MAX;
             let mut min_y = f32::MAX;
             let mut max_x = f32::MIN;
@@ -241,7 +208,6 @@ mod spatial {
                 max_y = max_y.max(pos.y);
             }
 
-            // Add padding and make square
             let padding = ((max_x - min_x) + (max_y - min_y)) * 0.1;
             min_x -= padding;
             min_y -= padding;
@@ -267,7 +233,6 @@ mod spatial {
     }
 }
 
-/// System to apply uniform gravity forces to entities
 pub fn apply_uniform_gravity(
     gravity: Res<UniformGravity>,
     mut query: Query<(Entity, &Mass, &mut AppliedForce), With<GravityAffected>>,
@@ -283,7 +248,6 @@ pub fn apply_uniform_gravity(
     }
 }
 
-/// System to calculate gravitational attraction between entities
 pub fn calculate_gravitational_attraction(
     gravity_params: Res<GravityParams>,
     query: Query<(Entity, &Transform, &Mass), With<GravitySource>>,
@@ -292,36 +256,33 @@ pub fn calculate_gravitational_attraction(
         With<GravityAffected>,
     >,
 ) {
-    // Get softening parameter squared once
     let softening_squared = gravity_params.softening * gravity_params.softening;
 
-    // Collect all gravity sources once
     let sources: Vec<(Entity, Vec3, f32)> = query
         .iter()
         .map(|(e, t, m)| (e, t.translation, m.value))
         .collect();
 
-    // Using Bevy's built-in parallelization - processes all affected entities in parallel
-    affected_query.par_iter_mut().for_each(|(affected_entity, affected_transform, affected_mass, mut force)| {
-        let affected_pos = affected_transform.translation;
-        
-        // Calculate the force from all sources on this affected entity
-        for &(source_entity, source_pos, source_mass) in &sources {
-            if source_entity == affected_entity {
-                continue;
+    affected_query.par_iter_mut().for_each(
+        |(affected_entity, affected_transform, affected_mass, mut force)| {
+            let affected_pos = affected_transform.translation;
+
+            for &(source_entity, source_pos, source_mass) in &sources {
+                if source_entity == affected_entity {
+                    continue;
+                }
+
+                let direction = source_pos - affected_pos;
+                let distance_squared = direction.length_squared();
+                let softened_distance_squared = distance_squared + softening_squared;
+                let force_magnitude = GRAVITATIONAL_CONSTANT * source_mass * affected_mass.value
+                    / softened_distance_squared;
+                force.force += direction.normalize() * force_magnitude;
             }
-            
-            let direction = source_pos - affected_pos;
-            force.force += calculate_softened_acceleration(
-                direction,
-                source_mass * affected_mass.value,
-                softening_squared,
-            );
-        }
-    });
+        },
+    );
 }
 
-/// System to calculate gravitational attraction using Barnes-Hut algorithm
 pub fn calculate_barnes_hut_attraction(
     gravity_params: Res<GravityParams>,
     query: Query<(Entity, &Transform, &Mass), With<GravitySource>>,
@@ -337,7 +298,6 @@ pub fn calculate_barnes_hut_attraction(
         return;
     }
 
-    // Create quadtree from gravity sources
     let bodies: Vec<(Entity, Vec3, f32)> = query
         .iter()
         .map(|(e, t, m)| (e, t.translation, m.value))
@@ -345,66 +305,65 @@ pub fn calculate_barnes_hut_attraction(
 
     let quadtree = spatial::Quadtree::from_bodies(&bodies);
 
-    // Using Bevy's built-in parallelization for the affected bodies
-    affected_query.par_iter_mut().for_each(|(entity, transform, _, mut force)| {
-        let position = transform.translation;
-        
-        // Skip self-attraction by checking if this entity is in the tree
-        if bodies.iter().any(|&(e, _, _)| e == entity) {
-            return; // Skip this iteration
-        }
-        
-        // Calculate force using Barnes-Hut algorithm
-        let force_vector = calculate_barnes_hut_force(
-            position, 
-            &quadtree.root, 
-            theta, 
-            gravity_params.softening
-        );
-        
-        force.force += force_vector;
-    });
+    affected_query
+        .par_iter_mut()
+        .for_each(|(entity, transform, _, mut force)| {
+            let position = transform.translation;
+
+            if bodies.iter().any(|&(e, _, _)| e == entity) {
+                return;
+            }
+
+            let force_vector = calculate_barnes_hut_force(
+                position,
+                &quadtree.root,
+                theta,
+                gravity_params.softening,
+            );
+
+            force.force += force_vector;
+        });
 }
 
-/// Calculate gravitational force using the Barnes-Hut approximation method
 pub fn calculate_barnes_hut_force(
     affected_position: Vec3,
     node: &spatial::QuadtreeNode,
     theta: f32,
     softening: f32,
 ) -> Vec3 {
-    // Get softening squared once
     let softening_squared = softening * softening;
 
-    // If the node is far enough, use approximation
     if node.is_far_enough(affected_position, theta) {
         let direction = node.mass_properties.center_of_mass - affected_position;
-        return calculate_softened_acceleration(
-            direction,
-            node.mass_properties.total_mass,
-            softening_squared,
-        );
+        let distance_squared = direction.length_squared();
+        let softened_distance_squared = distance_squared + softening_squared;
+        let force_magnitude =
+            GRAVITATIONAL_CONSTANT * node.mass_properties.total_mass / softened_distance_squared;
+        return direction.normalize() * force_magnitude;
     }
 
-    // If leaf node, calculate force from each body
     if node.children.iter().all(|c| c.is_none()) {
         let mut total_force = Vec3::ZERO;
 
         for &(_, position, mass) in &node.bodies {
             let direction = position - affected_position;
-            let distance_squared = direction.norm_squared();
+            let distance_squared = direction.length_squared();
 
             if distance_squared < 0.001 {
                 continue;
             }
 
-            total_force += calculate_softened_acceleration(direction, mass, softening_squared);
+            total_force += {
+                let distance_squared = direction.length_squared();
+                let softened_distance_squared = distance_squared + softening_squared;
+                let force_magnitude = GRAVITATIONAL_CONSTANT * mass / softened_distance_squared;
+                direction.normalize() * force_magnitude
+            };
         }
 
         return total_force;
     }
 
-    // Sum forces from children
     let mut total_force = Vec3::ZERO;
     for child in &node.children {
         if let Some(child_node) = child {
@@ -416,12 +375,10 @@ pub fn calculate_barnes_hut_force(
     total_force
 }
 
-/// Calculate orbital velocity for circular orbit
 pub fn calculate_orbital_velocity(central_mass: f32, orbit_radius: f32) -> f32 {
     (GRAVITATIONAL_CONSTANT * central_mass / orbit_radius).sqrt()
 }
 
-/// Calculate initial velocity for an elliptical orbit with given eccentricity
 pub fn calculate_elliptical_orbit_velocity(
     central_mass: f32,
     distance: f32,
@@ -433,12 +390,10 @@ pub fn calculate_elliptical_orbit_velocity(
     (mu * (2.0 / distance - 1.0 / semimajor_axis)).sqrt()
 }
 
-/// Calculate escape velocity from a massive body
 pub fn calculate_escape_velocity(central_mass: f32, distance: f32) -> f32 {
     (2.0 * GRAVITATIONAL_CONSTANT * central_mass / distance).sqrt()
 }
 
-/// Plugin for gravity systems
 #[derive(Default)]
 pub struct GravityPlugin {
     /// Use Barnes-Hut optimization for n-body simulations
@@ -448,28 +403,24 @@ pub struct GravityPlugin {
 }
 
 impl GravityPlugin {
-    /// Create new gravity plugin with default settings
     pub fn new() -> Self {
         Self {
             use_barnes_hut: true,
             barnes_hut_theta: 0.5,
         }
     }
-    
-    /// Configure whether to use Barnes-Hut optimization
+
     pub fn with_barnes_hut(mut self, enabled: bool) -> Self {
         self.use_barnes_hut = enabled;
         self
     }
-    
-    /// Set the Barnes-Hut theta parameter
+
     pub fn with_theta(mut self, theta: f32) -> Self {
         self.barnes_hut_theta = theta.clamp(0.1, 1.0);
         self
     }
 }
 
-/// System set for gravity calculations
 #[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
 pub enum GravitySet {
     /// Apply uniform gravity forces (like Earth's gravity)
@@ -480,61 +431,53 @@ pub enum GravitySet {
 
 impl Plugin for GravityPlugin {
     fn build(&self, app: &mut App) {
-        app
-            // Register default resources if not present
-            .init_resource::<GravityParams>()
+        app.init_resource::<GravityParams>()
             .init_resource::<UniformGravity>()
-            
-            // Configure gravity system sets
             .configure_sets(
                 Update,
-                (GravitySet::UniformGravity, GravitySet::NBodyGravity).chain()
+                (GravitySet::UniformGravity, GravitySet::NBodyGravity).chain(),
             )
-            
-            // Add gravity systems
             .add_systems(
                 Update,
-                apply_uniform_gravity
-                    .in_set(GravitySet::UniformGravity)
+                apply_uniform_gravity.in_set(GravitySet::UniformGravity),
             );
-            
-        // Add n-body gravity systems with run conditions
+
         if self.use_barnes_hut {
             let theta = self.barnes_hut_theta;
-            
+
             app.add_systems(
                 Update,
-                // Use a closure to pass the theta parameter
-                (move |
-                    gravity_params: Res<GravityParams>,
-                    query: Query<(Entity, &Transform, &Mass), With<GravitySource>>,
-                    affected_query: Query<(Entity, &Transform, &Mass, &mut AppliedForce), With<GravityAffected>>,
-                | {
+                (move |gravity_params: Res<GravityParams>,
+                       query: Query<(Entity, &Transform, &Mass), With<GravitySource>>,
+                       affected_query: Query<
+                    (Entity, &Transform, &Mass, &mut AppliedForce),
+                    With<GravityAffected>,
+                >| {
                     calculate_barnes_hut_attraction(gravity_params, query, affected_query, theta);
                 })
                 .in_set(GravitySet::NBodyGravity)
-                // Use run condition to only use Barnes-Hut for larger simulations
-                .run_if(|query: Query<(Entity, &Transform, &Mass), With<GravitySource>>| {
-                    query.iter().count() >= 20
-                })
+                .run_if(
+                    |query: Query<(Entity, &Transform, &Mass), With<GravitySource>>| {
+                        query.iter().count() >= 20
+                    },
+                ),
             );
-            
-            // Fallback to simple n-body for small simulations
+
             app.add_systems(
                 Update,
                 calculate_gravitational_attraction
                     .in_set(GravitySet::NBodyGravity)
-                    .run_if(|query: Query<(Entity, &Transform, &Mass), With<GravitySource>>| {
-                        query.iter().count() < 20
-                    })
+                    .run_if(
+                        |query: Query<(Entity, &Transform, &Mass), With<GravitySource>>| {
+                            query.iter().count() < 20
+                        },
+                    ),
             );
         } else {
-            // Always use simple n-body calculations if Barnes-Hut is disabled
             app.add_systems(
                 Update,
-                calculate_gravitational_attraction
-                    .in_set(GravitySet::NBodyGravity)
+                calculate_gravitational_attraction.in_set(GravitySet::NBodyGravity),
             );
         }
     }
-}
\ No newline at end of file
+}
diff --git a/crates/forces/src/core/mod.rs b/crates/forces/src/core/mod.rs
index 5a85137a..e6d55dc7 100644
--- a/crates/forces/src/core/mod.rs
+++ b/crates/forces/src/core/mod.rs
@@ -7,15 +7,15 @@ pub mod newton_laws;
 pub mod prelude {
     // Re-export from gravity module
     pub use crate::core::gravity::{
-        GravityParams, UniformGravity, GravityAffected, GravitySource, MassiveBody,
-        GRAVITATIONAL_CONSTANT, calculate_gravitational_attraction, 
-        calculate_orbital_velocity, calculate_elliptical_orbit_velocity, calculate_escape_velocity
+        calculate_elliptical_orbit_velocity, calculate_escape_velocity,
+        calculate_gravitational_attraction, calculate_orbital_velocity, GravityAffected,
+        GravityParams, GravitySource, MassiveBody, UniformGravity, GRAVITATIONAL_CONSTANT,
     };
-    
+
     // Re-export from newton_laws module
     pub use crate::core::newton_laws::{
-        Mass, AppliedForce, Velocity, PhysicsPlugin,
-        apply_forces, integrate_positions, calculate_momentum, calculate_kinetic_energy,
-        Norm, Distance, ForceImpulse, PairedForce, PairedForceInteraction
+        apply_forces, calculate_kinetic_energy, calculate_momentum, integrate_positions,
+        AppliedForce, Distance, ForceImpulse, Mass, NewtonLawsPlugin, Norm, PairedForce,
+        PairedForceInteraction, Velocity,
     };
-}
\ No newline at end of file
+}
diff --git a/crates/forces/src/core/newton_laws.rs b/crates/forces/src/core/newton_laws.rs
index 5f0cb895..de166b37 100644
--- a/crates/forces/src/core/newton_laws.rs
+++ b/crates/forces/src/core/newton_laws.rs
@@ -36,7 +36,7 @@ impl Norm for Vec2 {
 impl Distance for Vec2 {}
 
 /// Component for mass properties of an entity
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 pub struct Mass {
     /// Mass in kilograms
     pub value: f32,
@@ -86,7 +86,7 @@ impl Mass {
 }
 
 /// Component representing a force applied to an entity
-#[derive(Component, Debug, Clone)]
+#[derive(Component, Debug, Clone, Reflect)]
 pub struct AppliedForce {
     /// Force vector in Newtons
     pub force: Vec3,
@@ -128,7 +128,7 @@ impl AppliedForce {
 }
 
 /// Component for velocity (both linear and angular)
-#[derive(Component, Debug, Clone, Copy)]
+#[derive(Component, Debug, Clone, Copy, Reflect, Default)]
 pub struct Velocity {
     /// Linear velocity in meters per second
     pub linvel: Vec3,
@@ -136,15 +136,6 @@ pub struct Velocity {
     pub angvel: Vec3,
 }
 
-impl Default for Velocity {
-    fn default() -> Self {
-        Self {
-            linvel: Vec3::ZERO,
-            angvel: Vec3::ZERO,
-        }
-    }
-}
-
 /// System to apply forces according to Newton's Second Law (F = ma)
 pub fn apply_forces(time: Res<Time>, mut query: Query<(&Mass, &mut Velocity, &mut AppliedForce)>) {
     let dt = time.delta_secs();
@@ -229,11 +220,11 @@ impl ForceImpulse {
     }
 }
 
-/// Plugin that adds all physics systems in the correct order
+/// Plugin that adds Newton's Laws mechanics systems in the correct order
 #[derive(Default)]
-pub struct PhysicsPlugin;
+pub struct NewtonLawsPlugin;
 
-impl Plugin for PhysicsPlugin {
+impl Plugin for NewtonLawsPlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<ForceImpulse>().add_systems(
             Update,
@@ -248,25 +239,22 @@ pub fn compute_paired_forces<T: PairedForce + Resource>(
     entities: Query<(Entity, &Transform, &Mass), With<PairedForceInteraction>>,
     mut forces: Query<&mut AppliedForce>,
 ) {
-    let entity_list = entities.iter().collect::<Vec<_>>();
-
-    for i in 0..entity_list.len() {
-        for j in (i + 1)..entity_list.len() {
-            let pair = ForcePair {
-                first: entity_list[i],
-                second: entity_list[j],
-            };
+    for [(entity1, transform1, mass1), (entity2, transform2, mass2)] in entities.iter_combinations()
+    {
+        let pair = ForcePair {
+            first: (entity1, transform1, mass1),
+            second: (entity2, transform2, mass2),
+        };
 
-            let (force1, force2) = paired_force.compute_pair_force(pair);
+        let (force1, force2) = paired_force.compute_pair_force(pair);
 
-            // Apply calculated forces
-            if let Ok(mut force) = forces.get_mut(pair.first.0) {
-                force.force += force1;
-            }
+        // Apply calculated forces
+        if let Ok(mut force) = forces.get_mut(entity1) {
+            force.force += force1;
+        }
 
-            if let Ok(mut force) = forces.get_mut(pair.second.0) {
-                force.force += force2;
-            }
+        if let Ok(mut force) = forces.get_mut(entity2) {
+            force.force += force2;
         }
     }
 }
diff --git a/crates/forces/src/lib.rs b/crates/forces/src/lib.rs
index 9dcf2ca0..4ca4c3a0 100644
--- a/crates/forces/src/lib.rs
+++ b/crates/forces/src/lib.rs
@@ -1,26 +1,45 @@
 pub mod core;
 
 use bevy::prelude::*;
+pub use core::newton_laws::NewtonLawsPlugin;
 
 /// Force application interface for physical forces
 pub trait ForceApplicator: Send + Sync {
     /// Apply a force to an entity
     fn apply_force(&self, entity: Entity, force: Vec3);
-    
+
     /// Get the force magnitude
     fn get_magnitude(&self) -> f32;
-    
+
     /// Get the force direction
     fn get_direction(&self) -> Vec3;
 }
 
+/// Main plugin for all force-related systems
+#[derive(Default)]
+pub struct ForcesPlugin;
+
+impl Plugin for ForcesPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(NewtonLawsPlugin)
+            .register_type::<core::newton_laws::Mass>()
+            .register_type::<core::newton_laws::Velocity>()
+            .register_type::<core::newton_laws::AppliedForce>()
+            .register_type::<core::gravity::GravityAffected>()
+            .register_type::<core::gravity::GravitySource>()
+            .register_type::<core::gravity::MassiveBody>()
+            .init_resource::<core::gravity::GravityParams>()
+            .init_resource::<core::gravity::UniformGravity>();
+    }
+}
+
 /// The forces prelude.
 ///
 /// This includes the most common types in this crate, re-exported for your convenience.
 pub mod prelude {
     // Core interfaces from crate root
-    pub use crate::ForceApplicator;
-    
+    pub use crate::{ForceApplicator, ForcesPlugin};
+
     // Re-export core module prelude
     pub use crate::core::prelude::*;
-}
\ No newline at end of file
+}
diff --git a/crates/information/README.md b/crates/information/README.md
new file mode 100644
index 00000000..5eaefef9
--- /dev/null
+++ b/crates/information/README.md
@@ -0,0 +1,3 @@
+# Information
+
+Information theory, encoding, and computational information systems.
\ No newline at end of file
diff --git a/crates/information/src/fractals/fractals.rs b/crates/information/src/fractals/core.rs
similarity index 100%
rename from crates/information/src/fractals/fractals.rs
rename to crates/information/src/fractals/core.rs
diff --git a/crates/information/src/fractals/mod.rs b/crates/information/src/fractals/mod.rs
index 80db4eb3..be19a4bc 100644
--- a/crates/information/src/fractals/mod.rs
+++ b/crates/information/src/fractals/mod.rs
@@ -1,8 +1,8 @@
 //IMPORTANT DISCLAIMER: The fractals appraoch along JSON based and current predetermined/hardcoded appraoch will get override by PBMPM principles.
 // This is a temporary solution until we have a more dynamic and flexible system in place.
 
+pub mod core;
 pub mod data_loader;
-pub mod fractals;
 pub mod generator;
 pub mod grammar;
 pub mod interpreter;
@@ -10,14 +10,14 @@ pub mod renderer;
 
 pub mod prelude {
     // Core fractal functionality
-    pub use super::fractals::{LSystem, RuleManager};
+    pub use super::core::{LSystem, RuleManager};
     pub use super::generator::generate;
     pub use super::grammar::apply_rules;
-    
+
     // Interpreter and renderer
-    pub use super::interpreter::{InterpreterOutput, SymbolType, interpret};
+    pub use super::interpreter::{interpret, InterpreterOutput, SymbolType};
     pub use super::renderer::run_renderer;
-    
+
     // Data loading
-    pub use super::data_loader::{Template, Parameters, load_template};
-}
\ No newline at end of file
+    pub use super::data_loader::{load_template, Parameters, Template};
+}
diff --git a/crates/information/src/fractals/renderer.rs b/crates/information/src/fractals/renderer.rs
index f335ed01..b73e7079 100644
--- a/crates/information/src/fractals/renderer.rs
+++ b/crates/information/src/fractals/renderer.rs
@@ -50,10 +50,10 @@ fn setup_camera(mut commands: Commands) {
 /// Adjust thickness based on symbol type
 fn adjust_thickness_for_symbol(thickness: f32, symbol_type: SymbolType) -> f32 {
     match symbol_type {
-        SymbolType::Core => thickness * 1.5,      // Thicker for core elements
+        SymbolType::Core => thickness * 1.5, // Thicker for core elements
         SymbolType::Bifurcation => thickness * 1.2, // Slightly thicker for branch points
-        SymbolType::Segment => thickness,         // Standard thickness
-        SymbolType::Legacy => thickness,          // Standard thickness
+        SymbolType::Segment => thickness,    // Standard thickness
+        SymbolType::Legacy => thickness,     // Standard thickness
     }
 }
 
@@ -69,19 +69,19 @@ fn create_line_mesh(
     let direction = end - start;
     let length = direction.length();
     let angle = direction.y.atan2(direction.x);
-    
+
     // Create a simple rectangle mesh for the line
     let mesh = Mesh::from(Rectangle::new(length, thickness));
     let mesh_handle = meshes.add(mesh);
-    
+
     // Create a white material
     let material = materials.add(ColorMaterial::from(Color::WHITE));
-    
+
     // Calculate center position and rotation
     let center = (start + end) / 2.0;
-    let transform = Transform::from_translation(center.extend(0.0))
-        .with_rotation(Quat::from_rotation_z(angle));
-    
+    let transform =
+        Transform::from_translation(center.extend(0.0)).with_rotation(Quat::from_rotation_z(angle));
+
     (Mesh2d(mesh_handle), MeshMaterial2d(material), transform)
 }
 
@@ -135,13 +135,8 @@ fn draw_lsystem(
         let adjusted_thickness = adjust_thickness_for_symbol(base_thickness, symbol_type);
 
         // Create line mesh
-        let (mesh, material, transform) = create_line_mesh(
-            start,
-            end,
-            adjusted_thickness,
-            &mut meshes,
-            &mut materials,
-        );
+        let (mesh, material, transform) =
+            create_line_mesh(start, end, adjusted_thickness, &mut meshes, &mut materials);
 
         // Create the branch bundle
         let branch_bundle = BranchBundle {
@@ -202,4 +197,4 @@ pub fn run_renderer(
         }))
         .add_systems(Startup, (setup_camera, draw_lsystem))
         .run();
-}
\ No newline at end of file
+}
diff --git a/crates/information/src/lib.rs b/crates/information/src/lib.rs
index 2a40ec3c..24fb9f41 100644
--- a/crates/information/src/lib.rs
+++ b/crates/information/src/lib.rs
@@ -1,8 +1,29 @@
 pub mod fractals;
 
+use bevy::prelude::*;
+
+/// Main plugin for all information-related systems
+#[derive(Default)]
+pub struct InformationPlugin;
+
+impl Plugin for InformationPlugin {
+    fn build(&self, app: &mut App) {
+        // TODO: Add fractal systems when Bevy integration is implemented
+        // For now, just register the plugin to establish the structure
+        app.insert_resource(InformationSystemsInitialized);
+    }
+}
+
+/// Resource to indicate information systems are initialized
+#[derive(Resource, Default)]
+pub struct InformationSystemsInitialized;
+
 pub mod prelude {
+    // Main plugin export
+    pub use crate::InformationPlugin;
+
     // Re-export from fractals module
     pub use crate::fractals::prelude::*;
-    
+
     // Any future modules would be added here
-}
\ No newline at end of file
+}
diff --git a/crates/matter/README.md b/crates/matter/README.md
new file mode 100644
index 00000000..a7d7fdbb
--- /dev/null
+++ b/crates/matter/README.md
@@ -0,0 +1,3 @@
+# Matter
+
+Material properties and states including solids, fluids, gases, and plasma.
\ No newline at end of file
diff --git a/crates/matter/src/lib.rs b/crates/matter/src/lib.rs
index 2e461a7c..51627e91 100644
--- a/crates/matter/src/lib.rs
+++ b/crates/matter/src/lib.rs
@@ -1,6 +1,34 @@
 pub mod states;
 
+use bevy::prelude::*;
+
+/// Main plugin for all matter-related systems
+#[derive(Default)]
+pub struct MatterPlugin;
+
+impl Plugin for MatterPlugin {
+    fn build(&self, app: &mut App) {
+        // TODO: Add state-specific plugins when implementations are complete
+        // app.add_plugins((
+        //     SolidsPlugin,
+        //     FluidsPlugin,
+        //     GasesPlugin,
+        //     PlasmaPlugin,
+        // ));
+
+        // For now, just register the plugin to establish the structure
+        app.insert_resource(MatterSystemsInitialized);
+    }
+}
+
+/// Resource to indicate matter systems are initialized
+#[derive(Resource, Default)]
+pub struct MatterSystemsInitialized;
+
 pub mod prelude {
-    // Re-export from states module
+    // Main plugin export
+    pub use crate::MatterPlugin;
+
+    // Re-export from states module when ready
     //pub use crate::states::prelude::*;
-}
\ No newline at end of file
+}
diff --git a/crates/matter/src/states/fluids/mod.rs b/crates/matter/src/states/fluids/mod.rs
index ea91aec9..634230bd 100644
--- a/crates/matter/src/states/fluids/mod.rs
+++ b/crates/matter/src/states/fluids/mod.rs
@@ -6,4 +6,4 @@ pub mod solver;
 pub mod prelude {
     // Currently minimal, will expand with implementation
     // pub use super::solver::FluidSolver;
-}
\ No newline at end of file
+}
diff --git a/crates/matter/src/states/gases/mod.rs b/crates/matter/src/states/gases/mod.rs
index f0ee924c..70342df2 100644
--- a/crates/matter/src/states/gases/mod.rs
+++ b/crates/matter/src/states/gases/mod.rs
@@ -8,4 +8,4 @@ pub mod prelude {
     // Example future exports:
     // pub use super::pressure::PressureField;
     // pub use super::diffusion::DiffusionRate;
-}
\ No newline at end of file
+}
diff --git a/crates/matter/src/states/mod.rs b/crates/matter/src/states/mod.rs
index 1bf130e9..26fa5c65 100644
--- a/crates/matter/src/states/mod.rs
+++ b/crates/matter/src/states/mod.rs
@@ -1,7 +1,7 @@
-pub mod solids;
 pub mod fluids;
 pub mod gases;
 pub mod plasma;
+pub mod solids;
 
 /// Prelude for the matter states module.
 ///
@@ -12,4 +12,4 @@ pub mod prelude {
     //pub use super::fluids::prelude::*;
     //pub use super::gases::prelude::*;
     //pub use super::plasma::prelude::*;
-}
\ No newline at end of file
+}
diff --git a/crates/matter/src/states/plasma/mod.rs b/crates/matter/src/states/plasma/mod.rs
index 75ff20e1..9f71261b 100644
--- a/crates/matter/src/states/plasma/mod.rs
+++ b/crates/matter/src/states/plasma/mod.rs
@@ -8,4 +8,4 @@ pub mod prelude {
     // Example future exports:
     // pub use super::ionization::IonizationLevel;
     // pub use super::magnetic_coupling::MagneticCoupling;
-}
\ No newline at end of file
+}
diff --git a/crates/matter/src/states/solids/mod.rs b/crates/matter/src/states/solids/mod.rs
index ac8940ca..d4d3807a 100644
--- a/crates/matter/src/states/solids/mod.rs
+++ b/crates/matter/src/states/solids/mod.rs
@@ -8,4 +8,4 @@ pub mod prelude {
     // Example future exports:
     // pub use super::crystalline::CrystalStructure;
     // pub use super::deformation::ElasticDeformation;
-}
\ No newline at end of file
+}
diff --git a/crates/systems/Cargo.toml b/crates/systems/Cargo.toml
index b1422f3b..affa3ae4 100644
--- a/crates/systems/Cargo.toml
+++ b/crates/systems/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2021"
 description = "Core simulation infrastructure components that manage and support the virtual universe rather than represent parts of it."
 
 [dependencies]
+bevy = "0.16"
 save_system = { path = "./save_system" }
 pbmpm = { path = "./pbmpm" }
 acoustics = { path = "./acoustics" }
diff --git a/crates/systems/README.md b/crates/systems/README.md
new file mode 100644
index 00000000..0a111f99
--- /dev/null
+++ b/crates/systems/README.md
@@ -0,0 +1,3 @@
+# Systems
+
+High-level systems including AI, physics solvers, acoustics, and save systems.
\ No newline at end of file
diff --git a/crates/systems/acoustics/Cargo.toml b/crates/systems/acoustics/Cargo.toml
index 876d313e..f7a32e3b 100644
--- a/crates/systems/acoustics/Cargo.toml
+++ b/crates/systems/acoustics/Cargo.toml
@@ -5,4 +5,4 @@ edition = "2021"
 description = "Sound generation, playback, and spatial processing system for ambient and interactive audio experiences."
 
 [dependencies]
-bevy = "0.15"
\ No newline at end of file
+bevy = "0.16"
\ No newline at end of file
diff --git a/crates/systems/acoustics/src/lib.rs b/crates/systems/acoustics/src/lib.rs
index e69de29b..243d28da 100644
--- a/crates/systems/acoustics/src/lib.rs
+++ b/crates/systems/acoustics/src/lib.rs
@@ -0,0 +1,54 @@
+use bevy::prelude::*;
+
+/// Acoustics plugin for physics-based sound generation
+///
+/// Note: Acoustics in LP are generated from fundamental physics:
+/// - Sound waves are mechanical energy (from energy crate)  
+/// - Propagation requires matter medium (from matter crate)
+/// - All audio emerges from white noise + frequency filtering
+/// - No hardcoded audio files - everything is procedurally generated
+#[derive(Default)]
+pub struct AcousticsPlugin;
+
+impl Plugin for AcousticsPlugin {
+    fn build(&self, app: &mut App) {
+        // TODO: Will integrate with energy crate's wave systems
+        // TODO: Will require matter crate's medium properties for propagation
+        // TODO: White noise generation + frequency filtering system
+        app.register_type::<AcousticMedium>();
+    }
+}
+
+/// Properties of matter that affect sound propagation
+/// Will integrate with matter crate when ready
+#[derive(Component, Debug, Clone, Reflect)]
+pub struct AcousticMedium {
+    /// Speed of sound in this medium (m/s)
+    pub sound_speed: f32,
+    /// Density affects impedance and reflection
+    pub density: f32,
+    /// How much energy is absorbed per distance
+    pub absorption_coefficient: f32,
+}
+
+impl Default for AcousticMedium {
+    fn default() -> Self {
+        Self {
+            sound_speed: 343.0, // Air at 20°C
+            density: 1.225,     // Air density kg/m³
+            absorption_coefficient: 0.01,
+        }
+    }
+}
+
+/// Prelude for acoustics (minimal for now)
+pub mod prelude {
+    pub use super::{AcousticMedium, AcousticsPlugin};
+}
+
+// TODO: Future implementation will include:
+// - Integration with energy::waves for wave propagation
+// - Matter medium interaction for realistic sound physics
+// - White noise -> frequency filtering for emergent audio
+// - Doppler effects, reflection, interference patterns
+// - No audio files - pure procedural generation from physics
diff --git a/crates/systems/ai/Cargo.toml b/crates/systems/ai/Cargo.toml
index 5753675e..faee565c 100644
--- a/crates/systems/ai/Cargo.toml
+++ b/crates/systems/ai/Cargo.toml
@@ -4,9 +4,13 @@ version = "0.1.0"
 edition = "2021"
 description = "Utility-based AI framework for life form simulation with modular drives, memory, personality and relationships"
 
+[lib]
+doctest = false
+
 [dependencies]
 bevy = "0.16"
 rand = "0.9"
+energy = { path = "../../energy" }
 
 
 [features]
diff --git a/crates/systems/ai/src/core/actions.rs b/crates/systems/ai/src/core/actions.rs
index d3dd33ac..8a4e08f6 100644
--- a/crates/systems/ai/src/core/actions.rs
+++ b/crates/systems/ai/src/core/actions.rs
@@ -1,47 +1,28 @@
 //! Defines Action-related functionality. This module includes the
 //! ActionBuilder trait and some Composite Actions for utility.
-use std::sync::Arc;
-
-use bevy::prelude::*;
-
 use crate::core::thinkers::{Action, ActionSpan, Actor};
+use bevy::prelude::*;
+use std::sync::Arc;
 
 /// The current state for an Action. These states are changed by a combination
 /// of the Thinker that spawned it, and the actual Action system executing the
 /// Action itself.
-///
-/// Action system implementors should be mindful of taking appropriate action
-/// on all of these states, and be particularly careful when ignoring
-/// variants.
 #[derive(Debug, Clone, Component, Eq, PartialEq, Reflect)]
 #[component(storage = "SparseSet")]
 pub enum ActionState {
     /// Initial state. No action should be performed.
     Init,
-
-    /// Action requested. The Action-handling system should start executing
-    /// this Action ASAP and change the status to the next state.
+    /// Action requested. The Action-handling system should start executing this Action ASAP.
     Requested,
-
-    /// The action has ongoing execution. The associated Thinker will try to
-    /// keep executing this Action as-is until it changes state or it gets
-    /// Cancelled.
+    /// The action has ongoing execution.
     Executing,
-
-    /// An ongoing Action has been cancelled. The Thinker might set this
-    /// action for you, so for Actions that execute for longer than a single
-    /// tick, **you must check whether the Cancelled state was set** and
-    /// change do either Success or Failure. Thinkers will wait on Cancelled
-    /// actions to do any necessary cleanup work, so this can hang your AI if
-    /// you don't look for it.
+    /// An ongoing Action has been cancelled. **You must check whether the Cancelled state was set**
+    /// and change to either Success or Failure. Thinkers will wait on Cancelled actions to do
+    /// cleanup work, so this can hang your AI if you don't look for it.
     Cancelled,
-
-    /// The Action was a success. This is used by Composite Actions to
-    /// determine whether to continue execution.
+    /// The Action was a success.
     Success,
-
-    /// The Action failed. This is used by Composite Actions to determine
-    /// whether to halt execution.
+    /// The Action failed.
     Failure,
 }
 
@@ -70,63 +51,19 @@ impl ActionBuilderWrapper {
 }
 
 /// Trait that must be defined by types in order to be `ActionBuilder`s.
-/// `ActionBuilder`s' job is to spawn new `Action` entities on demand. In
-/// general, most of this is already done for you, and the only method you
-/// really have to implement is `.build()`.
-///
-/// The `build()` method MUST be implemented for any `ActionBuilder`s you want
-/// to define.
+/// The `build()` method MUST be implemented for any `ActionBuilder`s you want to define.
 #[reflect_trait]
 pub trait ActionBuilder: std::fmt::Debug + Send + Sync {
     /// MUST insert your concrete Action component into the Scorer [`Entity`],
-    /// using `cmd`. You _may_ use `actor`, but it's perfectly normal to just
-    /// ignore it.
-    ///
-    /// In most cases, your `ActionBuilder` and `Action` can be the same type.
-    /// The only requirement is that your struct implements `Debug`,
-    /// `Component, `Clone`. You can then use the derive macro `ActionBuilder`
-    /// to turn your struct into a `ActionBuilder`
-    ///
-    /// ### Example
-    ///
-    /// Using the derive macro (the easy way):
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use big_brain::prelude::*;
-    /// #[derive(Debug, Clone, Component, ActionBuilder)]
-    /// #[action_label = "MyActionLabel"] // Optional. Defaults to type name.
-    /// struct MyAction;
-    /// ```
-    ///
-    /// Implementing it manually:
-    ///
-    /// ```
-    /// # use bevy::prelude::*;
-    /// # use big_brain::prelude::*;
-    /// #[derive(Debug)]
-    /// struct MyBuilder;
-    /// #[derive(Debug, Component)]
-    /// struct MyAction;
-    ///
-    /// impl ActionBuilder for MyBuilder {
-    ///   fn build(&self, cmd: &mut Commands, action: Entity, actor: Entity) {
-    ///     cmd.entity(action).insert(MyAction);
-    ///   }
-    /// }
-    /// ```
+    /// using `cmd`. You _may_ use `actor`, but it's perfectly normal to just ignore it.
     fn build(&self, cmd: &mut Commands, action: Entity, actor: Entity);
 
-    /**
-     * A label to display when logging using the Action's tracing span.
-     */
     fn label(&self) -> Option<&str> {
         None
     }
 }
 
-/// Spawns a new Action Component, using the given ActionBuilder. This is
-/// useful when you're doing things like writing composite Actions.
+/// Spawns a new Action Component, using the given ActionBuilder.
 pub fn spawn_action<T: ActionBuilder + ?Sized>(
     builder: &T,
     cmd: &mut Commands,
@@ -146,8 +83,7 @@ pub fn spawn_action<T: ActionBuilder + ?Sized>(
     action_ent.entity()
 }
 
-/// [`ActionBuilder`] for the [`Steps`] component. Constructed through
-/// `Steps::build()`.
+/// [`ActionBuilder`] for the [`Steps`] component.
 #[derive(Debug, Reflect)]
 #[reflect(ActionBuilder)]
 pub struct StepsBuilder {
@@ -158,13 +94,11 @@ pub struct StepsBuilder {
 }
 
 impl StepsBuilder {
-    /// Sets the logging label for the Action
     pub fn label<S: Into<String>>(mut self, label: S) -> Self {
         self.label = Some(label.into());
         self
     }
 
-    /// Adds an action step. Order matters.
     pub fn step(mut self, action_builder: impl ActionBuilder + 'static) -> Self {
         if let Some(label) = action_builder.label() {
             self.steps_labels.push(label.into());
@@ -197,31 +131,7 @@ impl ActionBuilder for StepsBuilder {
     }
 }
 
-/// Composite Action that executes a series of steps in sequential order, as
-/// long as each step results in a `Success`ful [`ActionState`].
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyNextAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         MyScorer,
-///         Steps::build()
-///             .step(MyAction)
-///             .step(MyNextAction)
-///         )
-/// # ;
-/// # }
-/// ```
+/// Composite Action that executes a series of steps in sequential order.
 #[derive(Component, Debug, Reflect)]
 pub struct Steps {
     #[reflect(ignore)]
@@ -232,7 +142,6 @@ pub struct Steps {
 }
 
 impl Steps {
-    /// Construct a new [`StepsBuilder`] to define the steps to take.
     pub fn build() -> StepsBuilder {
         StepsBuilder {
             steps: Vec::new(),
@@ -242,7 +151,7 @@ impl Steps {
     }
 }
 
-/// System that takes care of executing any existing [`Steps`] Actions.
+/// System that executes [`Steps`] Actions.
 pub fn steps_system(
     mut cmd: Commands,
     mut steps_q: Query<(Entity, &Actor, &mut Steps, &ActionSpan)>,
@@ -254,9 +163,9 @@ pub fn steps_system(
         let current_state = states.get_mut(seq_ent).unwrap().clone();
         #[cfg(feature = "trace")]
         let _guard = _span.span().enter();
+
         match current_state {
             Requested => {
-                // Begin at the beginning
                 #[cfg(feature = "trace")]
                 trace!(
                     "Initializing StepsAction and requesting first step: {:?}",
@@ -268,18 +177,10 @@ pub fn steps_system(
             Executing => {
                 let mut step_state = states.get_mut(active_ent).unwrap();
                 match *step_state {
-                    Init => {
-                        // Request it! This... should not really happen? But just in case I'm missing something... :)
-                        *step_state = Requested;
-                    }
-                    Executing | Requested => {
-                        // do nothing. Everything's running as it should.
-                    }
-                    Cancelled => {
-                        // Wait for the step to wrap itself up, and we'll decide what to do at that point.
-                    }
+                    Init => *step_state = Requested,
+                    Executing | Requested => {}
+                    Cancelled => {}
                     Failure => {
-                        // Fail ourselves
                         #[cfg(feature = "trace")]
                         trace!("Step {:?} failed. Failing entire StepsAction.", active_ent);
                         let step_state = step_state.clone();
@@ -290,7 +191,6 @@ pub fn steps_system(
                         }
                     }
                     Success if steps_action.active_step == steps_action.steps.len() - 1 => {
-                        // We're done! Let's just be successful
                         #[cfg(feature = "trace")]
                         trace!("StepsAction completed all steps successfully.");
                         let step_state = step_state.clone();
@@ -303,11 +203,9 @@ pub fn steps_system(
                     Success => {
                         #[cfg(feature = "trace")]
                         trace!("Step succeeded, but there's more steps. Spawning next action.");
-                        // Deactivate current step and go to the next step
                         if let Ok(mut ent) = cmd.get_entity(steps_action.active_ent.entity()) {
                             ent.despawn();
                         }
-
                         steps_action.active_step += 1;
                         let step_builder = steps_action.steps[steps_action.active_step].clone();
                         let step_ent = spawn_action(step_builder.as_ref(), &mut cmd, *actor);
@@ -319,19 +217,16 @@ pub fn steps_system(
                 }
             }
             Cancelled => {
-                // Cancel current action
                 #[cfg(feature = "trace")]
                 trace!("StepsAction has been cancelled. Cancelling current step {:?} before finalizing.", active_ent);
                 let mut step_state = states.get_mut(active_ent).expect("oops");
-                if *step_state == Requested || *step_state == Executing || *step_state == Init {
+                if matches!(*step_state, Requested | Executing | Init) {
                     *step_state = Cancelled;
-                } else if *step_state == Failure || *step_state == Success {
+                } else if matches!(*step_state, Failure | Success) {
                     *states.get_mut(seq_ent).unwrap() = step_state.clone();
                 }
             }
-            Init | Success | Failure => {
-                // Do nothing.
-            }
+            Init | Success | Failure => {}
         }
     }
 }
@@ -339,14 +234,11 @@ pub fn steps_system(
 /// Configures what mode the [`Concurrently`] action will run in.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Reflect)]
 pub enum ConcurrentMode {
-    /// Reaches success when any of the concurrent actions reaches [`ActionState::Success`].
     Race,
-    /// Reaches success when all of the concurrent actions reach [`ActionState::Success`].
     Join,
 }
 
-/// [`ActionBuilder`] for the [`Concurrently`] component. Constructed through
-/// `Concurrently::build()`.
+/// [`ActionBuilder`] for the [`Concurrently`] component.
 #[derive(Debug, Reflect)]
 pub struct ConcurrentlyBuilder {
     mode: ConcurrentMode,
@@ -357,13 +249,11 @@ pub struct ConcurrentlyBuilder {
 }
 
 impl ConcurrentlyBuilder {
-    /// Sets the logging label for the Action
     pub fn label<S: Into<String>>(mut self, label: S) -> Self {
         self.label = Some(label.into());
         self
     }
 
-    /// Add an action to execute. Order does not matter.
     pub fn push(mut self, action_builder: impl ActionBuilder + 'static) -> Self {
         if let Some(label) = action_builder.label() {
             self.action_labels.push(label.into());
@@ -374,7 +264,6 @@ impl ConcurrentlyBuilder {
         self
     }
 
-    /// Sets the [`ConcurrentMode`] for this action.
     pub fn mode(mut self, mode: ConcurrentMode) -> Self {
         self.mode = mode;
         self
@@ -403,36 +292,7 @@ impl ActionBuilder for ConcurrentlyBuilder {
     }
 }
 
-/// Composite Action that executes a number of Actions concurrently. Whether
-/// this action succeeds depends on its [`ConcurrentMode`]:
-///
-/// * [`ConcurrentMode::Join`] (default) succeeds when **all** of the actions
-///   succeed.
-/// * [`ConcurrentMode::Race`] succeeds when **any** of the actions succeed.
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyOtherAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         MyScorer,
-///         Concurrently::build()
-///             .push(MyAction)
-///             .push(MyOtherAction)
-///         )
-/// # ;
-/// # }
-/// ```
-///
+/// Composite Action that executes a number of Actions concurrently.
 #[derive(Component, Debug, Reflect)]
 pub struct Concurrently {
     mode: ConcurrentMode,
@@ -441,7 +301,6 @@ pub struct Concurrently {
 }
 
 impl Concurrently {
-    /// Construct a new [`ConcurrentlyBuilder`] to define the actions to take.
     pub fn build() -> ConcurrentlyBuilder {
         ConcurrentlyBuilder {
             actions: Vec::new(),
@@ -452,7 +311,7 @@ impl Concurrently {
     }
 }
 
-/// System that takes care of executing any existing [`Concurrently`] Actions.
+/// System that executes [`Concurrently`] Actions.
 pub fn concurrent_system(
     concurrent_q: Query<(Entity, &Concurrently, &ActionSpan)>,
     mut states_q: Query<&mut ActionState>,
@@ -462,6 +321,7 @@ pub fn concurrent_system(
         let current_state = states_q.get_mut(seq_ent).expect("uh oh").clone();
         #[cfg(feature = "trace")]
         let _guard = _span.span.enter();
+
         match current_state {
             Requested => {
                 #[cfg(feature = "trace")]
@@ -469,7 +329,6 @@ pub fn concurrent_system(
                     "Initializing Concurrently action with {} children.",
                     concurrent_action.actions.len()
                 );
-                // Begin at the beginning
                 let mut current_state = states_q.get_mut(seq_ent).expect("uh oh");
                 *current_state = Executing;
                 for action in concurrent_action.actions.iter() {
@@ -502,21 +361,16 @@ pub fn concurrent_system(
                         }
                     }
                     if all_success {
-                        let mut state_var = states_q.get_mut(seq_ent).expect("uh oh");
-                        *state_var = Success;
+                        *states_q.get_mut(seq_ent).expect("uh oh") = Success;
                     } else if let Some(idx) = failed_idx {
                         for action in concurrent_action.actions.iter().take(idx) {
                             let child_ent = action.entity();
                             let mut child_state = states_q.get_mut(child_ent).expect("uh oh");
-                            match *child_state {
-                                Failure | Success => {}
-                                _ => {
-                                    *child_state = Cancelled;
-                                }
+                            if !matches!(*child_state, Failure | Success) {
+                                *child_state = Cancelled;
                             }
                         }
-                        let mut state_var = states_q.get_mut(seq_ent).expect("uh oh");
-                        *state_var = Failure;
+                        *states_q.get_mut(seq_ent).expect("uh oh") = Failure;
                     }
                 }
                 ConcurrentMode::Race => {
@@ -542,26 +396,20 @@ pub fn concurrent_system(
                         }
                     }
                     if all_failure {
-                        let mut state_var = states_q.get_mut(seq_ent).expect("uh oh");
-                        *state_var = Failure;
+                        *states_q.get_mut(seq_ent).expect("uh oh") = Failure;
                     } else if let Some(idx) = succeed_idx {
                         for action in concurrent_action.actions.iter().take(idx) {
                             let child_ent = action.entity();
                             let mut child_state = states_q.get_mut(child_ent).expect("uh oh");
-                            match *child_state {
-                                Failure | Success => {}
-                                _ => {
-                                    *child_state = Cancelled;
-                                }
+                            if !matches!(*child_state, Failure | Success) {
+                                *child_state = Cancelled;
                             }
                         }
-                        let mut state_var = states_q.get_mut(seq_ent).expect("uh oh");
-                        *state_var = Success;
+                        *states_q.get_mut(seq_ent).expect("uh oh") = Success;
                     }
                 }
             },
             Cancelled => {
-                // Cancel all actions
                 let mut all_done = true;
                 let mut any_failed = false;
                 let mut any_success = false;
@@ -570,12 +418,8 @@ pub fn concurrent_system(
                     let mut child_state = states_q.get_mut(child_ent).expect("uh oh");
                     match *child_state {
                         Init => {}
-                        Success => {
-                            any_success = true;
-                        }
-                        Failure => {
-                            any_failed = true;
-                        }
+                        Success => any_success = true,
+                        Failure => any_failed = true,
                         _ => {
                             all_done = false;
                             *child_state = Cancelled;
@@ -610,9 +454,7 @@ pub fn concurrent_system(
                     }
                 }
             }
-            Init | Success | Failure => {
-                // Do nothing.
-            }
+            Init | Success | Failure => {}
         }
     }
 }
diff --git a/crates/systems/ai/src/core/choices.rs b/crates/systems/ai/src/core/choices.rs
index 2150fe74..10de2743 100644
--- a/crates/systems/ai/src/core/choices.rs
+++ b/crates/systems/ai/src/core/choices.rs
@@ -57,4 +57,4 @@ impl ChoiceBuilder {
             action: ActionBuilderWrapper::new(self.then.clone()),
         }
     }
-}
\ No newline at end of file
+}
diff --git a/crates/systems/ai/src/core/evaluators.rs b/crates/systems/ai/src/core/evaluators.rs
index 89a53591..c6ad1b73 100644
--- a/crates/systems/ai/src/core/evaluators.rs
+++ b/crates/systems/ai/src/core/evaluators.rs
@@ -167,4 +167,4 @@ pub(crate) fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T {
     } else {
         val
     }
-}
\ No newline at end of file
+}
diff --git a/crates/systems/ai/src/core/mod.rs b/crates/systems/ai/src/core/mod.rs
index 885dc4d2..c09dbc3e 100644
--- a/crates/systems/ai/src/core/mod.rs
+++ b/crates/systems/ai/src/core/mod.rs
@@ -1,5 +1,5 @@
 //! Core AI module for LP
-//! 
+//!
 //! Provides a utility AI system with composable scorers, actions, and thinkers.
 //! Based on the Big Brain architecture but integrated into LP's ecosystem.
 
@@ -13,41 +13,37 @@ pub mod thinkers;
 pub mod utility;
 
 /// Prelude for the core AI module.
-/// 
+///
 /// This includes the most common types you'll need when working with LP's AI system.
 /// Use with `use crate::systems::ai::core::prelude::*;`
 pub mod prelude {
     // Actions (ActionBuilder and ActionState are in actions, but Action is in thinkers)
     pub use crate::core::actions::{
-        ActionBuilder, ActionState, ConcurrentMode, Concurrently, Steps
+        ActionBuilder, ActionState, ConcurrentMode, Concurrently, Steps,
     };
-    
-    // Scorers  
+
+    // Scorers
     pub use crate::core::scorers::{
-        AllOrNothing, EvaluatingScorer, FixedScore, MeasuredScorer, ProductOfScorers, 
-        Score, ScorerBuilder, SumOfScorers, WinningScorer
+        AllOrNothing, EvaluatingScorer, FixedScore, MeasuredScorer, ProductOfScorers, Score,
+        ScorerBuilder, SumOfScorers, WinningScorer,
     };
-    
+
     // Thinkers (includes Action, Actor, etc.)
     pub use crate::core::thinkers::{
-        Action, ActionSpan, Actor, HasThinker, Scorer, ScorerSpan, Thinker, ThinkerBuilder
+        Action, ActionSpan, Actor, HasThinker, Scorer, ScorerSpan, Thinker, ThinkerBuilder,
     };
-    
+
     // Evaluators
     pub use crate::core::evaluators::{
-        Evaluator, LinearEvaluator, PowerEvaluator, SigmoidEvaluator
+        Evaluator, LinearEvaluator, PowerEvaluator, SigmoidEvaluator,
     };
-    
+
     // Measures
-    pub use crate::core::measures::{
-        ChebyshevDistance, Measure, WeightedProduct, WeightedSum
-    };
-    
+    pub use crate::core::measures::{ChebyshevDistance, Measure, WeightedProduct, WeightedSum};
+
     // Pickers
-    pub use crate::core::pickers::{
-        FirstToScore, Highest, HighestToScore, Picker
-    };
-    
+    pub use crate::core::pickers::{FirstToScore, Highest, HighestToScore, Picker};
+
     // Choices
     pub use crate::core::choices::{Choice, ChoiceBuilder};
 
@@ -60,11 +56,13 @@ use bevy::{
 };
 
 /// Core plugin for LP's AI system. Provides utility AI functionality.
-/// 
+///
 /// Add this plugin to enable AI behaviors in your app.
-/// 
+///
 /// # Example
 /// ```rust
+/// # use bevy::prelude::*;
+/// # use ai::prelude::*;
 /// App::new()
 ///     .add_plugins(DefaultPlugins)
 ///     .add_plugins(LPAIPlugin::new(PreUpdate))
@@ -79,6 +77,12 @@ pub struct LPAIPlugin {
     cleanup_schedule: Interned<dyn ScheduleLabel>,
 }
 
+impl Default for LPAIPlugin {
+    fn default() -> Self {
+        Self::new(Update)
+    }
+}
+
 impl LPAIPlugin {
     /// Create the AI plugin which runs in the specified schedule
     pub fn new(schedule: impl ScheduleLabel) -> Self {
@@ -87,7 +91,7 @@ impl LPAIPlugin {
             cleanup_schedule: Last.intern(),
         }
     }
-    
+
     /// Set the schedule for cleanup tasks (default: Last)
     pub fn with_cleanup_schedule(mut self, cleanup_schedule: impl ScheduleLabel) -> Self {
         self.cleanup_schedule = cleanup_schedule.intern();
@@ -99,14 +103,9 @@ impl Plugin for LPAIPlugin {
     fn build(&self, app: &mut App) {
         app.configure_sets(
             self.schedule.intern(),
-            (
-                AISet::Scorers,
-                AISet::Thinkers,
-                AISet::Actions,
-            ).chain(),
+            (AISet::Scorers, AISet::Thinkers, AISet::Actions).chain(),
         )
         .configure_sets(self.cleanup_schedule.intern(), AISet::Cleanup)
-        
         // Add scorer systems
         .add_systems(
             self.schedule.intern(),
@@ -118,21 +117,19 @@ impl Plugin for LPAIPlugin {
                 scorers::product_of_scorers_system,
                 scorers::winning_scorer_system,
                 scorers::evaluating_scorer_system,
-            ).in_set(AISet::Scorers),
+            )
+                .in_set(AISet::Scorers),
         )
-        
         // Add thinker systems
         .add_systems(
             self.schedule.intern(),
             thinkers::thinker_system.in_set(AISet::Thinkers),
         )
-        
         // Add action systems
         .add_systems(
             self.schedule.intern(),
             (actions::steps_system, actions::concurrent_system).in_set(AISet::Actions),
         )
-        
         // Add cleanup systems
         .add_systems(
             self.cleanup_schedule.intern(),
@@ -140,7 +137,8 @@ impl Plugin for LPAIPlugin {
                 thinkers::thinker_component_attach_system,
                 thinkers::thinker_component_detach_system,
                 thinkers::actor_gone_cleanup,
-            ).in_set(AISet::Cleanup),
+            )
+                .in_set(AISet::Cleanup),
         );
     }
 }
@@ -156,4 +154,4 @@ pub enum AISet {
     Actions,
     /// Cleanup tasks run last
     Cleanup,
-}
\ No newline at end of file
+}
diff --git a/crates/systems/ai/src/core/pickers.rs b/crates/systems/ai/src/core/pickers.rs
index d900ea9e..383f1f69 100644
--- a/crates/systems/ai/src/core/pickers.rs
+++ b/crates/systems/ai/src/core/pickers.rs
@@ -20,7 +20,7 @@ pub trait Picker: std::fmt::Debug + Sync + Send {
 /// ### Example
 ///
 /// ```
-/// # use big_brain::prelude::*;
+/// # use ai::prelude::*;
 /// # fn main() {
 /// Thinker::build()
 ///     .picker(FirstToScore::new(0.8))
@@ -56,7 +56,7 @@ impl Picker for FirstToScore {
 /// ### Example
 ///
 /// ```
-/// # use big_brain::prelude::*;
+/// # use ai::prelude::*;
 /// # fn main() {
 /// Thinker::build()
 ///     .picker(Highest)
@@ -90,7 +90,7 @@ impl Picker for Highest {
 /// ### Example
 ///
 /// ```
-/// # use big_brain::prelude::*;
+/// # use ai::prelude::*;
 /// # fn main() {
 /// Thinker::build()
 ///     .picker(HighestToScore::new(0.8))
diff --git a/crates/systems/ai/src/core/scorers.rs b/crates/systems/ai/src/core/scorers.rs
index f378359f..0dbc4544 100644
--- a/crates/systems/ai/src/core/scorers.rs
+++ b/crates/systems/ai/src/core/scorers.rs
@@ -43,13 +43,7 @@ impl Score {
     }
 }
 
-/// Trait that must be defined by types in order to be `ScorerBuilder`s.
-/// `ScorerBuilder`s' job is to spawn new `Scorer` entities. In general, most
-/// of this is already done for you, and the only method you really have to
-/// implement is `.build()`.
-///
-/// The `build()` method MUST be implemented for any `ScorerBuilder`s you want
-/// to define.
+/// Trait for building scorer components. Must implement `build()`.
 #[reflect_trait]
 pub trait ScorerBuilder: std::fmt::Debug + Sync + Send {
     /// MUST insert your concrete Scorer component into the Scorer [`Entity`],
@@ -67,7 +61,7 @@ pub trait ScorerBuilder: std::fmt::Debug + Sync + Send {
     ///
     /// ```
     /// # use bevy::prelude::*;
-    /// # use big_brain::prelude::*;
+    /// # use ai::prelude::*;
     /// #[derive(Debug, Clone, Component, ScorerBuilder)]
     /// #[scorer_label = "MyScorerLabel"] // Optional. Defaults to type name.
     /// struct MyScorer;
@@ -77,7 +71,7 @@ pub trait ScorerBuilder: std::fmt::Debug + Sync + Send {
     ///
     /// ```
     /// # use bevy::prelude::*;
-    /// # use big_brain::prelude::*;
+    /// # use ai::prelude::*;
     /// #[derive(Debug)]
     /// struct MyBuilder;
     /// #[derive(Debug, Component)]
@@ -91,7 +85,7 @@ pub trait ScorerBuilder: std::fmt::Debug + Sync + Send {
     /// ```
     fn build(&self, cmd: &mut Commands, scorer: Entity, actor: Entity);
 
-    /// A label to display when logging using the Scorer's tracing span.
+    /// Optional label for logging.
     fn label(&self) -> Option<&str> {
         None
     }
@@ -116,8 +110,8 @@ pub fn spawn_scorer<T: ScorerBuilder + ?Sized>(
     scorer_ent
 }
 
-/// Scorer that always returns the same, fixed score. Good for combining with
-/// things creatively!
+/// Scorer that always returns the same, fixed score.
+
 #[derive(Clone, Component, Debug, Reflect)]
 pub struct FixedScore(pub f32);
 
@@ -161,31 +155,7 @@ impl ScorerBuilder for FixedScorerBuilder {
     }
 }
 
-/// Composite Scorer that takes any number of other Scorers and returns the
-/// sum of their [`Score`] values if each _individual_ [`Score`] is at or
-/// above the configured `threshold`.
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyOtherScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         AllOrNothing::build(0.8)
-///           .push(MyScorer)
-///           .push(MyOtherScorer),
-///         MyAction);
-/// # ;
-/// # }
-/// ```
+/// Composite Scorer: sums scores if all individual scores >= threshold.
 #[derive(Component, Debug, Reflect)]
 pub struct AllOrNothing {
     threshold: f32,
@@ -218,7 +188,7 @@ pub fn all_or_nothing_system(
     {
         let mut sum = 0.0;
         for Scorer(child) in children.iter() {
-            let score = scores.get_mut(*child).expect("where is it?");
+            let score = scores.get_mut(*child).expect("score missing");
             if score.0 < *threshold {
                 sum = 0.0;
                 break;
@@ -226,7 +196,7 @@ pub fn all_or_nothing_system(
                 sum += score.0;
             }
         }
-        let mut score = scores.get_mut(aon_ent).expect("where did it go?");
+        let mut score = scores.get_mut(aon_ent).expect("score missing");
         score.set(crate::core::evaluators::clamp(sum, 0.0, 1.0));
         #[cfg(feature = "trace")]
         {
@@ -257,7 +227,6 @@ impl AllOrNothingBuilder {
         self
     }
 
-    /// Set a label for this Action.
     pub fn label(mut self, label: impl AsRef<str>) -> Self {
         self.label = Some(label.as_ref().into());
         self
@@ -286,29 +255,7 @@ impl ScorerBuilder for AllOrNothingBuilder {
     }
 }
 
-/// Composite Scorer that takes any number of other Scorers and returns the sum of their [`Score`] values if the _total_ summed [`Score`] is at or above the configured `threshold`.
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyOtherScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         SumOfScorers::build(0.8)
-///           .push(MyScorer)
-///           .push(MyOtherScorer),
-///         MyAction)
-/// # ;
-/// # }
-/// ```
+/// Composite Scorer: sums all scores, returns 0 if total < threshold.
 #[derive(Component, Debug, Reflect)]
 pub struct SumOfScorers {
     threshold: f32,
@@ -413,37 +360,7 @@ impl ScorerBuilder for SumOfScorersBuilder {
     }
 }
 
-/// Composite Scorer that takes any number of other Scorers and returns the
-/// product of their [`Score`]. If the resulting score is less than the
-/// threshold, it returns 0.
-///
-/// The Scorer can also apply a compensation factor based on the number of
-/// Scores passed to it. This can be enabled by passing `true` to the
-/// `use_compensation` method on the builder.
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyOtherScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         ProductOfScorers::build(0.5)
-///           .use_compensation(true)
-///           .push(MyScorer)
-///           .push(MyOtherScorer),
-///         MyAction)
-/// # ;
-/// # }
-/// ```
-
+/// Composite Scorer: multiplies all scores with optional compensation factor.
 #[derive(Component, Debug, Reflect)]
 pub struct ProductOfScorers {
     threshold: f32,
@@ -573,32 +490,7 @@ impl ScorerBuilder for ProductOfScorersBuilder {
     }
 }
 
-/// Composite Scorer that takes any number of other Scorers and returns the
-/// single highest value [`Score`] if  _any_ [`Score`]s are at or above the
-/// configured `threshold`.
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyOtherScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         WinningScorer::build(0.8)
-///           .push(MyScorer)
-///           .push(MyOtherScorer),
-///         MyAction)
-/// # ;
-/// # }
-/// ```
-
+/// Composite Scorer: returns highest score if any score >= threshold.
 #[derive(Component, Debug, Reflect)]
 pub struct WinningScorer {
     threshold: f32,
@@ -640,7 +532,11 @@ pub fn winning_scorer_system(
             None => 0.0,
         };
         let mut score = scores.get_mut(sos_ent).expect("where did it go?");
-        score.set(crate::core::evaluators::clamp(winning_score_or_zero, 0.0, 1.0));
+        score.set(crate::core::evaluators::clamp(
+            winning_score_or_zero,
+            0.0,
+            1.0,
+        ));
         #[cfg(feature = "trace")]
         {
             let _guard = _span.span().enter();
@@ -703,34 +599,7 @@ impl ScorerBuilder for WinningScorerBuilder {
     }
 }
 
-/// Composite scorer that takes a `ScorerBuilder` and applies an `Evaluator`.
-/// Note that unlike other composite scorers, `EvaluatingScorer` only takes
-/// one scorer upon building.
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # #[derive(Debug, Clone)]
-/// # struct MyEvaluator;
-/// # impl Evaluator for MyEvaluator {
-/// #    fn evaluate(&self, score: f32) -> f32 {
-/// #        score
-/// #    }
-/// # }
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         EvaluatingScorer::build(MyScorer, MyEvaluator),
-///         MyAction)
-/// # ;
-/// # }
-/// ```
+/// Applies an Evaluator to transform a single scorer's output.
 #[derive(Component, Debug, Reflect)]
 #[reflect(from_reflect = false)]
 pub struct EvaluatingScorer {
@@ -812,56 +681,7 @@ impl ScorerBuilder for EvaluatingScorerBuilder {
     }
 }
 
-/// Composite Scorer that allows more fine-grained control of how the scores
-/// are combined. The default is to apply a weighting
-///
-/// ### Example
-///
-/// Using the default measure ([`WeightedMeasure`]):
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyOtherScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         MeasuredScorer::build(0.5)
-///           .push(MyScorer, 0.9)
-///           .push(MyOtherScorer, 0.4),
-///         MyAction)
-/// # ;
-/// # }
-/// ```
-///
-/// Customising the measure:
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyScorer;
-/// # #[derive(Debug, Clone, Component, ScorerBuilder)]
-/// # struct MyOtherScorer;
-/// # #[derive(Debug, Clone, Component, ActionBuilder)]
-/// # struct MyAction;
-/// # fn main() {
-/// Thinker::build()
-///     .when(
-///         MeasuredScorer::build(0.5)
-///           .measure(ChebyshevDistance)
-///           .push(MyScorer, 0.8)
-///           .push(MyOtherScorer, 0.2),
-///         MyAction)
-/// # ;
-/// # }
-/// ```
-
+/// Composite Scorer: combines scores using customizable Measure (default: weighted).
 #[derive(Component, Debug, Reflect)]
 #[reflect(from_reflect = false)]
 pub struct MeasuredScorer {
diff --git a/crates/systems/ai/src/core/thinkers.rs b/crates/systems/ai/src/core/thinkers.rs
index a5dfd9b0..b87dce24 100644
--- a/crates/systems/ai/src/core/thinkers.rs
+++ b/crates/systems/ai/src/core/thinkers.rs
@@ -23,9 +23,7 @@ use crate::core::{
 };
 
 /// Wrapper for Actor entities. In terms of Scorers, Thinkers, and Actions,
-/// this is the [`Entity`] actually _performing_ the action, rather than the
-/// entity a Scorer/Thinker/Action is attached to. Generally, you will use
-/// this entity when writing Queries for Action and Scorer systems.
+/// this is the Entity actually performing the action.
 #[derive(Debug, Clone, Component, Copy, Reflect)]
 pub struct Actor(pub Entity);
 
@@ -93,41 +91,6 @@ impl ScorerSpan {
 /// The "brains" behind this whole operation. A `Thinker` is what glues
 /// together `Actions` and `Scorers` and shapes larger, intelligent-seeming
 /// systems.
-///
-/// Note: Thinkers are also Actions, so anywhere you can pass in an Action (or
-/// [`ActionBuilder`]), you can pass in a Thinker (or [`ThinkerBuilder`]).
-///
-/// ### Example
-///
-/// ```
-/// # use bevy::prelude::*;
-/// # use big_brain::prelude::*;
-/// # #[derive(Component, Debug)]
-/// # struct Thirst(f32, f32);
-/// # #[derive(Component, Debug)]
-/// # struct Hunger(f32, f32);
-/// # #[derive(Clone, Component, Debug, ScorerBuilder)]
-/// # struct Thirsty;
-/// # #[derive(Clone, Component, Debug, ScorerBuilder)]
-/// # struct Hungry;
-/// # #[derive(Clone, Component, Debug, ActionBuilder)]
-/// # struct Drink;
-/// # #[derive(Clone, Component, Debug, ActionBuilder)]
-/// # struct Eat;
-/// # #[derive(Clone, Component, Debug, ActionBuilder)]
-/// # struct Meander;
-/// pub fn init_entities(mut cmd: Commands) {
-///     cmd.spawn((
-///         Thirst(70.0, 2.0),
-///         Hunger(50.0, 3.0),
-///         Thinker::build()
-///             .picker(FirstToScore::new(80.0))
-///             .when(Thirsty, Drink)
-///             .when(Hungry, Eat)
-///             .otherwise(Meander),
-///     ));
-/// }
-/// ```
 #[derive(Component, Debug, Reflect)]
 #[reflect(from_reflect = false)]
 pub struct Thinker {
@@ -147,8 +110,7 @@ pub struct Thinker {
 }
 
 impl Thinker {
-    /// Make a new [`ThinkerBuilder`]. This is what you'll actually use to
-    /// configure Thinker behavior.
+    /// Make a new [`ThinkerBuilder`].
     pub fn build() -> ThinkerBuilder {
         ThinkerBuilder::new()
     }
@@ -159,8 +121,7 @@ impl Thinker {
     }
 }
 
-/// This is what you actually use to configure Thinker behavior. It's a plain
-/// old [`ActionBuilder`], as well.
+/// This is what you actually use to configure Thinker behavior.
 #[derive(Component, Clone, Debug, Default)]
 pub struct ThinkerBuilder {
     picker: Option<Arc<dyn Picker>>,
@@ -179,14 +140,13 @@ impl ThinkerBuilder {
         }
     }
 
-    /// Define a [`Picker`](crate::pickers::Picker) for this Thinker.
+    /// Define a [`Picker`] for this Thinker.
     pub fn picker(mut self, picker: impl Picker + 'static) -> Self {
         self.picker = Some(Arc::new(picker));
         self
     }
 
-    /// Define an [`ActionBuilder`](crate::actions::ActionBuilder) and
-    /// [`ScorerBuilder`](crate::scorers::ScorerBuilder) pair.
+    /// Define an [`ActionBuilder`] and [`ScorerBuilder`] pair.
     pub fn when(
         mut self,
         scorer: impl ScorerBuilder + 'static,
@@ -197,14 +157,13 @@ impl ThinkerBuilder {
         self
     }
 
-    /// Default `Action` to execute if the `Picker` did not pick any of the
-    /// given choices.
+    /// Default `Action` to execute if the `Picker` did not pick any choices.
     pub fn otherwise(mut self, otherwise: impl ActionBuilder + 'static) -> Self {
         self.otherwise = Some(ActionBuilderWrapper::new(Arc::new(otherwise)));
         self
     }
 
-    /// * Configures a label to use for the thinker when logging.
+    /// Configures a label to use for the thinker when logging.
     pub fn label(mut self, label: impl AsRef<str>) -> Self {
         self.label = Some(label.as_ref().to_string());
         self
@@ -228,7 +187,6 @@ impl ActionBuilder for ThinkerBuilder {
         std::mem::drop(_guard);
         cmd.entity(action_ent)
             .insert(Thinker {
-                // TODO: reasonable default?...
                 picker: self
                     .picker
                     .clone()
@@ -278,7 +236,6 @@ pub fn actor_gone_cleanup(
 ) {
     for (child, Actor(actor)) in q.iter() {
         if actors.get(*actor).is_err() {
-            // Actor is gone. Let's clean up.
             if let Ok(mut ent) = cmd.get_entity(child) {
                 ent.despawn();
             }
@@ -342,39 +299,43 @@ pub fn thinker_system(
             }
             ActionState::Requested => {
                 let mut act_state = action_states.get_mut(thinker_ent).expect("???");
-                debug!("Thinker requested. Starting execution.");
+                debug!("Starting execution.");
                 *act_state = ActionState::Executing;
             }
             ActionState::Success | ActionState::Failure => {}
             ActionState::Cancelled => {
-                debug!("Thinker cancelled. Cleaning up.");
+                debug!("Cleaning up.");
                 if let Some(current) = &mut thinker.current_action {
                     let action_span = action_spans.get(current.0 .0).expect("Where is it?");
-                    debug!("Cancelling current action because thinker was cancelled.");
-                    let state = action_states.get_mut(current.0.0).expect("Couldn't find a component corresponding to the current action. This is definitely a bug.").clone();
+                    debug!("Cancelling current action.");
+                    let state = action_states
+                        .get_mut(current.0 .0)
+                        .expect("Missing current action")
+                        .clone();
                     match state {
                         ActionState::Success | ActionState::Failure => {
-                            debug!("Action already wrapped up on its own. Cleaning up action in Thinker.");
+                            debug!("Action already wrapped up.");
                             if let Ok(mut ent) = cmd.get_entity(current.0 .0) {
                                 ent.despawn();
                             }
                             thinker.current_action = None;
                         }
                         ActionState::Cancelled => {
-                            debug!("Current action already cancelled.");
+                            debug!("Already cancelled.");
                         }
                         _ => {
-                            let mut state = action_states.get_mut(current.0.0).expect("Couldn't find a component corresponding to the current action. This is definitely a bug.");
-                            debug!( "Action is still executing. Attempting to cancel it before wrapping up Thinker cancellation.");
+                            let mut state =
+                                action_states.get_mut(current.0 .0).expect("Missing action");
+                            debug!("Action still executing. Cancelling it.");
                             action_span.span.in_scope(|| {
-                                debug!("Parent thinker was cancelled. Cancelling action.");
+                                debug!("Cancelling action.");
                             });
                             *state = ActionState::Cancelled;
                         }
                     }
                 } else {
                     let mut act_state = action_states.get_mut(thinker_ent).expect("???");
-                    debug!("No current thinker action. Wrapping up Thinker as Succeeded.");
+                    debug!("No current action. Completing as Success.");
                     *act_state = ActionState::Success;
                 }
             }
@@ -382,9 +343,6 @@ pub fn thinker_system(
                 #[cfg(feature = "trace")]
                 trace!("Thinker is executing. Thinking...");
                 if let Some(choice) = thinker.picker.pick(&thinker.choices, &scores) {
-                    // Think about what action we're supposed to be taking. We do this
-                    // every tick, because we might change our mind.
-                    // ...and then execute it (details below).
                     #[cfg(feature = "trace")]
                     trace!("Action picked. Executing picked action.");
                     let action = choice.action.clone();
@@ -411,7 +369,6 @@ pub fn thinker_system(
                     thinker.current_action = Some((Action(new_action), action.clone()));
                     thinker.current_action_label = Some(action.1.label().map(|s| s.into()));
                 } else if let Some(default_action_ent) = &thinker.otherwise {
-                    // Otherwise, let's just execute the default one! (if it's there)
                     let default_action_ent = default_action_ent.clone();
                     exec_picked_action(
                         &mut cmd,
@@ -427,16 +384,15 @@ pub fn thinker_system(
                 } else if let Some((action_ent, _)) = &thinker.current_action {
                     let action_span = action_spans.get(action_ent.0).expect("Where is it?");
                     let _guard = action_span.span.enter();
-                    let mut curr_action_state = action_states.get_mut(action_ent.0).expect("Couldn't find a component corresponding to the current action. This is definitely a bug.");
+                    let mut curr_action_state = action_states
+                        .get_mut(action_ent.0)
+                        .expect("Missing current action");
                     let previous_done = matches!(
                         *curr_action_state,
                         ActionState::Success | ActionState::Failure
                     );
                     if previous_done {
-                        debug!(
-                            "Action completed and nothing was picked. Despawning action entity.",
-                        );
-                        // Despawn the action itself.
+                        debug!("Action completed. Despawning.");
                         if let Ok(mut ent) = cmd.get_entity(action_ent.0) {
                             ent.despawn();
                         }
@@ -467,7 +423,9 @@ fn should_schedule_action(
         trace!("No scheduled actions. Not scheduling anything.");
         false
     } else if let Some((action_ent, _)) = &mut thinker.current_action {
-        let curr_action_state = states.get_mut(action_ent.0).expect("Couldn't find a component corresponding to the current action. This is definitely a bug.");
+        let curr_action_state = states
+            .get_mut(action_ent.0)
+            .expect("Missing current action");
 
         let action_done = matches!(
             *curr_action_state,
@@ -501,21 +459,12 @@ fn exec_picked_action(
     scorer_spans: &Query<&ScorerSpan>,
     override_current: bool,
 ) {
-    // If we do find one, then we need to grab the corresponding
-    // component for it. The "action" that `picker.pick()` returns
-    // is just a newtype for an Entity.
-    //
-
-    // Now we check the current action. We need to check if we picked the same one as the previous tick.
-    //
-    // TODO: I don't know where the right place to put this is
-    // (maybe not in this logic), but we do need some kind of
-    // oscillation protection so we're not just bouncing back and
-    // forth between the same couple of actions.
     let thinker_span = thinker.span.clone();
     let _thinker_span_guard = thinker_span.enter();
     if let Some((action_ent, ActionBuilderWrapper(current_id, _))) = &mut thinker.current_action {
-        let mut curr_action_state = states.get_mut(action_ent.0).expect("Couldn't find a component corresponding to the current action. This is definitely a bug.");
+        let mut curr_action_state = states
+            .get_mut(action_ent.0)
+            .expect("Missing current action");
         let previous_done = matches!(
             *curr_action_state,
             ActionState::Success | ActionState::Failure
@@ -523,11 +472,6 @@ fn exec_picked_action(
         let action_span = action_spans.get(action_ent.0).expect("Where is it?");
         let _guard = action_span.span.enter();
         if (!Arc::ptr_eq(current_id, &picked_action.0) && override_current) || previous_done {
-            // So we've picked a different action than we were
-            // currently executing. Just like before, we grab the
-            // actual Action component (and we assume it exists).
-            // If the action is executing, or was requested, we
-            // need to cancel it to make sure it stops.
             if !previous_done {
                 if override_current {
                     #[cfg(feature = "trace")]
@@ -539,19 +483,18 @@ fn exec_picked_action(
             }
             match *curr_action_state {
                 ActionState::Executing | ActionState::Requested => {
-                    debug!("Previous action is still executing. Requesting action cancellation.",);
+                    debug!("Requesting cancellation.");
                     *curr_action_state = ActionState::Cancelled;
                 }
                 ActionState::Init | ActionState::Success | ActionState::Failure => {
-                    debug!("Previous action already completed. Despawning action entity.",);
-                    // Despawn the action itself.
+                    debug!("Previous action completed. Despawning.");
                     if let Ok(mut ent) = cmd.get_entity(action_ent.0) {
                         ent.despawn();
                     }
                     if let Some((Scorer(ent), score)) = scorer_info {
                         let scorer_span = scorer_spans.get(*ent).expect("Where is it?");
                         let _guard = scorer_span.span.enter();
-                        debug!("Winning scorer chosen with score {}", score.get());
+                        debug!("Winning score: {}", score.get());
                     }
                     std::mem::drop(_guard);
                     debug!("Spawning next action");
@@ -562,37 +505,24 @@ fn exec_picked_action(
                 }
                 ActionState::Cancelled => {
                     #[cfg(feature = "trace")]
-                    trace!(
-                    "Cancellation already requested. Waiting for action to be marked as completed.",
-                )
+                    trace!("Cancellation already requested. Waiting.");
                 }
             };
-        } else {
-            // Otherwise, it turns out we want to keep executing
-            // the same action. Just in case, we go ahead and set
-            // it as Requested if for some reason it had finished
-            // but the Action System hasn't gotten around to
-            // cleaning it up.
-            if *curr_action_state == ActionState::Init {
-                *curr_action_state = ActionState::Requested;
-            }
-            #[cfg(feature = "trace")]
-            trace!("Continuing execution of current action.",)
+        } else if *curr_action_state == ActionState::Init {
+            *curr_action_state = ActionState::Requested;
         }
+        #[cfg(feature = "trace")]
+        trace!("Continuing execution of current action.",)
     } else {
         #[cfg(feature = "trace")]
         trace!("Falling back to `otherwise` clause.",);
 
-        // This branch arm is called when there's no
-        // current_action in the thinker. The logic here is pretty
-        // straightforward -- we set the action, Request it, and
-        // that's it.
         if let Some((Scorer(ent), score)) = scorer_info {
             let scorer_span = scorer_spans.get(*ent).expect("Where is it?");
             let _guard = scorer_span.span.enter();
-            debug!("Winning scorer chosen with score {}", score.get());
+            debug!("Winning score: {}", score.get());
         }
-        debug!("No current action. Spawning new action.");
+        debug!("No current action. Spawning new.");
         let new_action = actions::spawn_action(picked_action.1.as_ref(), cmd, actor);
         thinker.current_action = Some((Action(new_action), picked_action.clone()));
         thinker.current_action_label = Some(picked_action.1.label().map(|s| s.into()));
diff --git a/crates/systems/ai/src/core/utility.rs b/crates/systems/ai/src/core/utility.rs
index 79055dac..9cc7f563 100644
--- a/crates/systems/ai/src/core/utility.rs
+++ b/crates/systems/ai/src/core/utility.rs
@@ -1,11 +1,11 @@
+use crate::prelude::*;
 use bevy::prelude::*;
 use rand::prelude::*; //still plan to use bevy_rand instead
-use crate::prelude::*;
 use std::collections::HashMap;
 
 /// Represents a utility score for decision-making
 /// Normalized between 0.0 and 1.0
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Component)]
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Component, Reflect)]
 pub struct UtilityScore(f32);
 
 impl UtilityScore {
@@ -28,7 +28,11 @@ impl UtilityScore {
             }
         } else {
             // If all scores are 0, distribute evenly
-            let equal_value = if scores.is_empty() { 0.0 } else { 1.0 / scores.len() as f32 };
+            let equal_value = if scores.is_empty() {
+                0.0
+            } else {
+                1.0 / scores.len() as f32
+            };
             for score in scores.iter_mut() {
                 *score = UtilityScore::new(equal_value);
             }
@@ -65,7 +69,10 @@ impl UtilityScore {
     }
 
     /// Perform weighted random selection between multiple options
-    pub fn weighted_select<T: Clone, R: Rng>(options: &[(T, UtilityScore)], rng: &mut R) -> Option<T> {
+    pub fn weighted_select<T: Clone, R: Rng>(
+        options: &[(T, UtilityScore)],
+        rng: &mut R,
+    ) -> Option<T> {
         let total_weight: f32 = options.iter().map(|(_, score)| score.value()).sum();
         if total_weight <= 0.0 || options.is_empty() {
             return None;
@@ -96,28 +103,29 @@ pub enum Behavior {
 }
 
 /// Selects the most appropriate behavior based on module utility scores
-pub fn determine_behavior<'a>(
-    modules: &[(&'a dyn AIModule, UtilityScore, Behavior)],
+pub fn determine_behavior(
+    modules: &[(&dyn AIModule, UtilityScore, Behavior)],
 ) -> (Behavior, UtilityScore) {
     if modules.is_empty() {
         return (Behavior::Idle, UtilityScore::new(0.0));
     }
-    
+
     // Create normalized version of the scores for better decision making
-    let mut normalized_scores: Vec<UtilityScore> = modules.iter().map(|(_, score, _)| *score).collect();
+    let mut normalized_scores: Vec<UtilityScore> =
+        modules.iter().map(|(_, score, _)| *score).collect();
     UtilityScore::normalize_scores(&mut normalized_scores);
-    
+
     // Find behavior with highest normalized score
     let mut best_index = 0;
     let mut best_score = normalized_scores[0];
-    
+
     for (i, score) in normalized_scores.iter().enumerate().skip(1) {
         if score > &best_score {
             best_score = *score;
             best_index = i;
         }
     }
-    
+
     // Return the original behavior and original score (not normalized)
     // This preserves the absolute utility value while making selection based on normalized scores
     let (_, original_score, behavior) = modules[best_index];
@@ -154,7 +162,7 @@ impl UtilityCache {
             ttl,
         }
     }
-    
+
     /// Get cached value if not expired
     pub fn get(&self, key: &str, current_time: f32) -> Option<UtilityScore> {
         self.cache.get(key).and_then(|cached| {
@@ -165,31 +173,41 @@ impl UtilityCache {
             }
         })
     }
-    
+
     /// Store value with timestamp
     pub fn insert(&mut self, key: String, value: UtilityScore, current_time: f32) {
-        self.cache.insert(key, CachedValue { value, timestamp: current_time });
+        self.cache.insert(
+            key,
+            CachedValue {
+                value,
+                timestamp: current_time,
+            },
+        );
     }
-    
+
     /// Get value if cached, otherwise calculate and store
-    pub fn get_or_insert_with<F>(&mut self, key: String, calculator: F, current_time: f32) -> UtilityScore 
+    pub fn get_or_insert_with<F>(
+        &mut self,
+        key: String,
+        calculator: F,
+        current_time: f32,
+    ) -> UtilityScore
     where
         F: FnOnce() -> UtilityScore,
     {
         if let Some(value) = self.get(&key, current_time) {
             return value;
         }
-        
+
         let value = calculator();
         self.insert(key, value, current_time);
         value
     }
-    
+
     /// Clean up expired entries
     pub fn cleanup(&mut self, current_time: f32) {
-        self.cache.retain(|_, cached| {
-            current_time - cached.timestamp < self.ttl
-        });
+        self.cache
+            .retain(|_, cached| current_time - cached.timestamp < self.ttl);
     }
 }
 
@@ -210,17 +228,22 @@ impl EntityUtilityCache {
             }
         })
     }
-    
+
     /// Store value with timestamp
     pub fn insert(&mut self, key: String, value: UtilityScore, current_time: f32) {
-        self.cache.insert(key, CachedValue { value, timestamp: current_time });
+        self.cache.insert(
+            key,
+            CachedValue {
+                value,
+                timestamp: current_time,
+            },
+        );
     }
-    
+
     /// Clean up expired entries
     pub fn cleanup(&mut self, current_time: f32, ttl: f32) {
-        self.cache.retain(|_, cached| {
-            current_time - cached.timestamp < ttl
-        });
+        self.cache
+            .retain(|_, cached| current_time - cached.timestamp < ttl);
     }
 }
 
@@ -230,44 +253,44 @@ pub trait CacheableModule: AIModule {
     fn cache_key(&self) -> Option<String> {
         None // Default implementation returns None (no caching)
     }
-    
+
     /// Get utility with caching if available
     fn cached_utility(
-        &self, 
+        &self,
         entity_cache: Option<&mut EntityUtilityCache>,
-        global_cache: Option<&mut UtilityCache>, 
-        current_time: f32
+        global_cache: Option<&mut UtilityCache>,
+        current_time: f32,
     ) -> UtilityScore {
         // Try to get a cache key
-        let Some(key) = self.cache_key() else { 
+        let Some(key) = self.cache_key() else {
             return self.utility(); // No key means no caching
         };
-        
+
         // Try entity cache first (better locality and parallelism)
         if let Some(entity_cache) = entity_cache {
             let ttl = global_cache.as_ref().map(|c| c.ttl).unwrap_or(0.5);
-            
+
             if let Some(value) = entity_cache.get(&key, current_time, ttl) {
                 return value;
             }
-            
+
             // Not in entity cache, calculate and store
             let value = self.utility();
             entity_cache.insert(key.clone(), value, current_time);
-            
+
             // Also update global cache if available
             if let Some(global_cache) = global_cache {
                 global_cache.insert(key, value, current_time);
             }
-            
+
             return value;
         }
-        
+
         // No entity cache, try global cache
         if let Some(global_cache) = global_cache {
             return global_cache.get_or_insert_with(key, || self.utility(), current_time);
         }
-        
+
         // No caching available, calculate directly
         self.utility()
     }
@@ -280,10 +303,10 @@ pub fn cleanup_utility_cache_system(
     mut entity_caches: Query<&mut EntityUtilityCache>,
 ) {
     let current_time = time.elapsed_secs_f64() as f32;
-    
+
     // Clean up global cache
     global_cache.cleanup(current_time);
-    
+
     // Clean up entity caches
     for mut entity_cache in &mut entity_caches {
         entity_cache.cleanup(current_time, global_cache.ttl);
@@ -298,5 +321,5 @@ pub fn get_current_time(time: &Time) -> f32 {
 /// Simple function to initialize the caching system
 pub fn setup_utility_caching(app: &mut App, ttl: f32) {
     app.insert_resource(UtilityCache::new(ttl))
-       .add_systems(Last, cleanup_utility_cache_system);
-}
\ No newline at end of file
+        .add_systems(Last, cleanup_utility_cache_system);
+}
diff --git a/crates/systems/ai/src/drives/mod.rs b/crates/systems/ai/src/drives/mod.rs
index 7a601b74..1f2f38b1 100644
--- a/crates/systems/ai/src/drives/mod.rs
+++ b/crates/systems/ai/src/drives/mod.rs
@@ -1,8 +1,22 @@
 pub mod needs;
 
+use bevy::prelude::*;
+
+/// Plugin for biological drive systems
+#[derive(Default)]
+pub struct DrivesPlugin;
+
+impl Plugin for DrivesPlugin {
+    fn build(&self, _app: &mut App) {
+        // Simple plugin - just makes drives available
+        // Systems will be added later when we have proper integration
+    }
+}
+
 /// Prelude for the drives module.
 ///
 /// This includes core need types and drive components.
 pub mod prelude {
-    pub use crate::drives::needs::{Need, NeedType, update_needs, get_most_urgent_need};
-}
\ No newline at end of file
+    pub use crate::drives::needs::{get_most_urgent_need, update_needs, Need, NeedType};
+    pub use crate::drives::DrivesPlugin;
+}
diff --git a/crates/systems/ai/src/drives/needs.rs b/crates/systems/ai/src/drives/needs.rs
index 1f70410d..40a7c551 100644
--- a/crates/systems/ai/src/drives/needs.rs
+++ b/crates/systems/ai/src/drives/needs.rs
@@ -1,14 +1,13 @@
-use bevy::prelude::*;
 use crate::prelude::*;
-
+use bevy::prelude::*;
 
 /// Core need types representing basic drives
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum NeedType {
-    Hunger,     // Need for nourishment
-    Safety,     // Need to avoid danger
-    Rest,       // Need for recuperation
-    Social,     // Need for group interaction
+    Hunger, // Need for nourishment
+    Safety, // Need to avoid danger
+    Rest,   // Need for recuperation
+    Social, // Need for group interaction
 }
 
 /// Component representing a single need
@@ -46,10 +45,7 @@ impl Need {
 }
 
 /// System for updating needs over time
-pub fn update_needs(
-    time: Res<Time>,
-    mut needs: Query<&mut Need>,
-) {
+pub fn update_needs(time: Res<Time>, mut needs: Query<&mut Need>) {
     for mut need in &mut needs {
         need.satisfaction = (need.satisfaction - need.depletion_rate * time.delta_secs()).max(0.0);
     }
@@ -80,11 +76,11 @@ impl AIModule for Need {
         // (Note: Full implementation would use time delta)
         self.satisfaction = (self.satisfaction - self.depletion_rate * 0.01).max(0.0);
     }
-    
+
     fn utility(&self) -> UtilityScore {
         // Return urgency as utility
         self.urgency()
     }
 }
 
-//TODO: Adding a NeedTracker to monitor and manage needs over time, would be in systems/ai/src/trackers/needs_tracker.rs
\ No newline at end of file
+//TODO: Adding a NeedTracker to monitor and manage needs over time, would be in systems/ai/src/trackers/needs_tracker.rs
diff --git a/crates/systems/ai/src/lib.rs b/crates/systems/ai/src/lib.rs
index 4942f347..22c355a4 100644
--- a/crates/systems/ai/src/lib.rs
+++ b/crates/systems/ai/src/lib.rs
@@ -5,30 +5,45 @@ pub mod personality;
 pub mod relationships;
 pub mod trackers;
 
+/// Main AI plugin that provides the complete AI system
+pub use crate::core::LPAIPlugin;
+
 /// The AI prelude.
 ///
 /// This includes the most common types in this crate, re-exported for your convenience.
 pub mod prelude {
+    // Main plugins for easy access
+    pub use crate::drives::DrivesPlugin;
+    pub use crate::personality::PersonalityPlugin;
+    pub use crate::relationships::SocialPlugin;
+    pub use crate::trackers::TrackerPlugin;
+    pub use crate::LPAIPlugin;
+
     // Core interfaces - now directly from crate root
     pub use crate::{AIModule, ActionExecutor};
-    
+
     // Re-export module preludes
     pub use crate::core::prelude::*;
-    pub use crate::trackers::prelude::*;
+    pub use crate::drives::prelude::*;
     pub use crate::memory::prelude::*;
     pub use crate::personality::prelude::*;
     pub use crate::relationships::prelude::*;
-    pub use crate::drives::prelude::*;
+    pub use crate::trackers::prelude::*;
+
+    // Context-aware personality system
+    pub use crate::personality::traits::{
+        update_collective_influence, update_context_aware_utilities, ContextAwareUtilities,
+    };
 }
 
-use bevy::prelude::*;
 use crate::core::utility::UtilityScore;
+use bevy::prelude::*;
 
 /// Base trait for all AI modules
 pub trait AIModule: Send + Sync {
     /// Update the module's internal state
     fn update(&mut self);
-    
+
     /// Calculate the utility value of this module
     fn utility(&self) -> UtilityScore;
 }
@@ -37,15 +52,15 @@ pub trait AIModule: Send + Sync {
 pub trait ActionExecutor {
     /// Move toward a target position
     fn move_toward(&mut self, target: Vec2, speed: f32) -> bool;
-    
+
     /// Perform an attack action
     fn attack(&mut self, target: Option<Entity>) -> bool;
-    
+
     /// Move away from a threat  
     fn flee_from(&mut self, threat: Vec2) -> bool;
-    
+
     /// Idle/rest at current position
     fn idle(&mut self, duration: f32) -> bool;
-    
+
     fn cleanup(&mut self);
 }
diff --git a/crates/systems/ai/src/memory/mod.rs b/crates/systems/ai/src/memory/mod.rs
index 5819f2ca..ad1fb79c 100644
--- a/crates/systems/ai/src/memory/mod.rs
+++ b/crates/systems/ai/src/memory/mod.rs
@@ -4,5 +4,7 @@ pub mod types;
 ///
 /// This includes types for storing and managing entity memories.
 pub mod prelude {
-    pub use crate::memory::types::{MemoryEvent, MemoryEventType, MemoryTimestamp};
-}
\ No newline at end of file
+    pub use crate::memory::types::{
+        MemoryEvent, MemoryEventType, MemoryTimestamp, ShortTermMemory,
+    };
+}
diff --git a/crates/systems/ai/src/memory/types.rs b/crates/systems/ai/src/memory/types.rs
index 5bd5592c..db7e150e 100644
--- a/crates/systems/ai/src/memory/types.rs
+++ b/crates/systems/ai/src/memory/types.rs
@@ -1,6 +1,5 @@
-use bevy::prelude::*;
 use crate::prelude::*;
-
+use bevy::prelude::*;
 
 /// Memory timestamp (game ticks)
 pub type MemoryTimestamp = u64;
@@ -8,17 +7,17 @@ pub type MemoryTimestamp = u64;
 /// Types of memory events
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum MemoryEventType {
-    Interaction,  // Entity interactions
-    Threat,       // Dangerous situations
-    Resource,     // Food, shelter, etc.
-    Social,       // Group dynamics
+    Interaction, // Entity interactions
+    Threat,      // Dangerous situations
+    Resource,    // Food, shelter, etc.
+    Social,      // Group dynamics
 }
 
 /// Basic memory event
 #[derive(Debug, Clone, Component)]
 pub struct MemoryEvent {
     pub timestamp: MemoryTimestamp,
-    pub importance: UtilityScore,  // Use UtilityScore instead of raw f32
+    pub importance: UtilityScore, // Use UtilityScore instead of raw f32
     // pub location: Option<Vec2>, // Commented out until terrain is implemented
     pub related_entities: Vec<Entity>,
     pub event_type: MemoryEventType,
@@ -29,12 +28,12 @@ impl MemoryEvent {
         Self {
             event_type,
             timestamp,
-            importance: UtilityScore::new(importance),  // Convert to UtilityScore
+            importance: UtilityScore::new(importance), // Convert to UtilityScore
             // location: None,
             related_entities: Vec::new(),
         }
     }
-    
+
     pub fn with_entity(mut self, entity: Entity) -> Self {
         self.related_entities.push(entity);
         self
@@ -46,9 +45,46 @@ impl AIModule for MemoryEvent {
         // Memories don't need regular updates
         // Could implement decay of importance over time if needed
     }
-    
+
     fn utility(&self) -> UtilityScore {
         // Return importance as utility
         self.importance
     }
-}
\ No newline at end of file
+}
+
+/// Simple short-term memory for AI decisions
+#[derive(Component, Debug, Clone, Reflect, Default)]
+pub struct ShortTermMemory {
+    pub recent_interactions: Vec<(Entity, RelationshipType, f32)>, // who, what, strength
+    pub max_memories: usize,
+}
+
+impl ShortTermMemory {
+    pub fn new(max_memories: usize) -> Self {
+        Self {
+            recent_interactions: Vec::new(),
+            max_memories,
+        }
+    }
+
+    pub fn remember_interaction(
+        &mut self,
+        entity: Entity,
+        relationship: RelationshipType,
+        strength: f32,
+    ) {
+        self.recent_interactions
+            .push((entity, relationship, strength));
+        if self.recent_interactions.len() > self.max_memories {
+            self.recent_interactions.remove(0);
+        }
+    }
+
+    pub fn recall_relationship(&self, entity: Entity) -> Option<f32> {
+        self.recent_interactions
+            .iter()
+            .filter(|(e, _, _)| *e == entity)
+            .map(|(_, _, strength)| *strength)
+            .last() // Most recent interaction
+    }
+}
diff --git a/crates/systems/ai/src/personality/mod.rs b/crates/systems/ai/src/personality/mod.rs
index 57bbe604..a57c2de0 100644
--- a/crates/systems/ai/src/personality/mod.rs
+++ b/crates/systems/ai/src/personality/mod.rs
@@ -1,8 +1,22 @@
 pub mod traits;
 
+use bevy::prelude::*;
+
+/// Plugin for personality and behavioral trait systems
+#[derive(Default)]
+pub struct PersonalityPlugin;
+
+impl Plugin for PersonalityPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<traits::Personality>()
+            .register_type::<traits::Altruistic>();
+    }
+}
+
 /// Prelude for the personality module.
 ///
 /// This includes personality traits and related components.
 pub mod prelude {
-    pub use crate::personality::traits::Personality;
-}
\ No newline at end of file
+    pub use crate::personality::traits::{Altruistic, Personality};
+    pub use crate::personality::PersonalityPlugin;
+}
diff --git a/crates/systems/ai/src/personality/traits.rs b/crates/systems/ai/src/personality/traits.rs
index 9e6a759b..aff17321 100644
--- a/crates/systems/ai/src/personality/traits.rs
+++ b/crates/systems/ai/src/personality/traits.rs
@@ -1,68 +1,76 @@
-use bevy::prelude::*;
 use crate::prelude::*;
+use bevy::prelude::*;
+use energy::prelude::*;
 
-/// Core personality traits for AI entities
-#[derive(Component, Debug, Clone)]
+/// Universal life adaptation traits for all organisms (plants through animals)
+#[derive(Component, Debug, Clone, Reflect)]
 pub struct Personality {
-    /// Affects aggression and attack likelihood (0.0-1.0)
-    pub aggression: f32,
-    /// Determines fear response threshold (0.0-1.0)
-    pub bravery: f32,
-    /// Affects social hierarchy position (0.0-1.0)
-    pub dominance: f32,
+    /// How aggressively entity competes for resources (0.0-1.0)
+    /// Plants: root/canopy competition, Animals: territorial behavior
+    pub resource_assertiveness: f32,
+    /// Ability to handle environmental pressure (0.0-1.0)
+    /// Plants: drought/heat tolerance, Animals: threat response
+    pub stress_tolerance: f32,
+    /// Success in territorial/resource conflicts (0.0-1.0)
+    /// Plants: canopy dominance, Animals: social hierarchy
+    pub competitive_strength: f32,
 }
 
 impl Default for Personality {
     fn default() -> Self {
         Self {
-            aggression: 0.5,
-            bravery: 0.5,
-            dominance: 0.5,
+            resource_assertiveness: 0.5,
+            stress_tolerance: 0.5,
+            competitive_strength: 0.5,
         }
     }
 }
 
 impl Personality {
     /// Create a new personality with specified values
-    pub fn new(aggression: f32, bravery: f32, dominance: f32) -> Self {
+    pub fn new(
+        resource_assertiveness: f32,
+        stress_tolerance: f32,
+        competitive_strength: f32,
+    ) -> Self {
         Self {
-            aggression: aggression.clamp(0.0, 1.0),
-            bravery: bravery.clamp(0.0, 1.0),
-            dominance: dominance.clamp(0.0, 1.0),
+            resource_assertiveness: resource_assertiveness.clamp(0.0, 1.0),
+            stress_tolerance: stress_tolerance.clamp(0.0, 1.0),
+            competitive_strength: competitive_strength.clamp(0.0, 1.0),
         }
     }
-    
-    /// How likely the entity is to attack
-    pub fn attack_likelihood(&self) -> f32 {
-        // Higher aggression and bravery increase attack likelihood
-        self.aggression * 0.7 + self.bravery * 0.3
-    }
-    
-    /// How likely the entity is to flee from threats
-    pub fn flee_likelihood(&self) -> f32 {
-        // Lower bravery increases flee likelihood
-        1.0 - self.bravery
-    }
-    
-    /// Get attack behavior utility score
-    pub fn attack_utility(&self) -> UtilityScore {
-        UtilityScore::new(self.attack_likelihood())
-    }
-    
-    /// Get flee behavior utility score
-    pub fn flee_utility(&self) -> UtilityScore {
-        UtilityScore::new(self.flee_likelihood())
-    }
-    
-    /// Get dominance behavior utility score
-    pub fn dominance_utility(&self) -> UtilityScore {
-        UtilityScore::new(self.dominance)
-    }
-    
+
+    /// How likely the entity is to compete for resources
+    pub fn resource_competition_likelihood(&self) -> f32 {
+        // Higher resource assertiveness and competitive strength increase competition
+        self.resource_assertiveness * 0.7 + self.competitive_strength * 0.3
+    }
+
+    /// How likely the entity is to retreat from stress/threats  
+    pub fn stress_retreat_likelihood(&self) -> f32 {
+        // Lower stress tolerance increases retreat likelihood
+        1.0 - self.stress_tolerance
+    }
+
+    /// Get base resource competition behavior utility score
+    pub fn base_resource_competition_utility(&self) -> UtilityScore {
+        UtilityScore::new(self.resource_competition_likelihood())
+    }
+
+    /// Get base stress retreat behavior utility score
+    pub fn base_stress_retreat_utility(&self) -> UtilityScore {
+        UtilityScore::new(self.stress_retreat_likelihood())
+    }
+
+    /// Get base competitive behavior utility score
+    pub fn base_competitive_utility(&self) -> UtilityScore {
+        UtilityScore::new(self.competitive_strength)
+    }
+
     /// Get social behavior utility score
     pub fn social_utility(&self) -> f32 {
-        // Lower aggression and higher dominance increases social interaction utility
-        (1.0 - self.aggression * 0.3) + (self.dominance * 0.3)
+        // Lower resource competition and higher competitive strength increases cooperation utility
+        (1.0 - self.resource_assertiveness * 0.3) + (self.competitive_strength * 0.3)
     }
 }
 
@@ -71,9 +79,201 @@ impl AIModule for Personality {
         // Personality traits are generally stable
         // but could evolve slowly based on experiences
     }
-    
+
     fn utility(&self) -> UtilityScore {
         // Return a base utility score for personality-driven behaviors
         UtilityScore::new(0.5)
     }
-}
\ No newline at end of file
+}
+
+/// Component marking an entity as having altruistic tendencies
+/// Universal trait applicable to any creature type in LP ecosystem
+#[derive(Component, Debug, Clone, Reflect)]
+pub struct Altruistic {
+    /// Strength of altruistic behavior (0.0-1.0)
+    pub strength: f32,
+    /// Hunger threshold below which altruism is active (0.0-1.0)
+    pub activation_threshold: f32,
+}
+
+impl Default for Altruistic {
+    fn default() -> Self {
+        Self {
+            strength: 0.7,
+            activation_threshold: 0.7, // Only altruistic when hunger < 70%
+        }
+    }
+}
+
+impl Altruistic {
+    pub fn new(strength: f32, activation_threshold: f32) -> Self {
+        Self {
+            strength: strength.clamp(0.0, 1.0),
+            activation_threshold: activation_threshold.clamp(0.0, 1.0),
+        }
+    }
+
+    /// Check if entity should exhibit altruistic behavior given current hunger
+    pub fn should_be_altruistic(&self, hunger_level: f32) -> bool {
+        hunger_level < self.activation_threshold
+    }
+
+    /// Get altruistic behavior utility score
+    pub fn altruistic_utility(&self, hunger_level: f32) -> UtilityScore {
+        if self.should_be_altruistic(hunger_level) {
+            UtilityScore::new(self.strength)
+        } else {
+            UtilityScore::new(0.0)
+        }
+    }
+}
+
+/// Component storing context-aware utility scores (updated by systems)
+#[derive(Component, Debug, Clone, Reflect)]
+pub struct ContextAwareUtilities {
+    pub resource_competition: UtilityScore,
+    pub stress_retreat: UtilityScore,
+    pub competitive_behavior: UtilityScore,
+    pub cooperation: UtilityScore,
+    /// Collective intelligence modifier from nearby entities (swarm effects)
+    pub collective_influence: UtilityScore,
+}
+
+impl Default for ContextAwareUtilities {
+    fn default() -> Self {
+        Self {
+            resource_competition: UtilityScore::new(0.5),
+            stress_retreat: UtilityScore::new(0.5),
+            competitive_behavior: UtilityScore::new(0.5),
+            cooperation: UtilityScore::new(0.5),
+            collective_influence: UtilityScore::new(0.0),
+        }
+    }
+}
+
+/// System that updates personality utilities based on energy and thermal state
+pub fn update_context_aware_utilities(
+    mut query: Query<(
+        &Personality,
+        &mut ContextAwareUtilities,
+        Option<&EnergyQuantity>,
+        Option<&EnergyAccountingLedger>,
+        Option<&Temperature>,
+    )>,
+) {
+    for (personality, mut utilities, energy_opt, ledger_opt, temp_opt) in &mut query {
+        // Energy context
+        let energy_level = energy_opt
+            .map(|e| e.value / e.max_capacity.unwrap_or(100.0))
+            .unwrap_or(0.5);
+
+        let recent_success = ledger_opt
+            .map(|l| l.net_energy_change() / 10.0)
+            .unwrap_or(0.0)
+            .clamp(-0.5, 0.5);
+
+        // Thermal stress context
+        let environmental_stress = temp_opt
+            .map(|t| (t.value - 298.0).abs() / 50.0)
+            .unwrap_or(0.0)
+            .clamp(0.0, 1.0);
+
+        // Update utilities with physics context
+        utilities.resource_competition =
+            calculate_contextual_resource_competition(personality, energy_level, recent_success);
+
+        utilities.competitive_behavior =
+            calculate_contextual_competitive_strength(personality, energy_level, recent_success);
+
+        utilities.stress_retreat =
+            calculate_contextual_stress_retreat(personality, energy_level, environmental_stress);
+
+        utilities.cooperation = UtilityScore::new(personality.social_utility());
+
+        // collective_influence is calculated by separate proximity-based systems
+        // when entities are near each other - starts at 0.0 for isolated entities
+    }
+}
+
+/// System that calculates collective influence from nearby social relations
+/// Universal swarm intelligence - works for plant root networks, animal herds, bacterial colonies
+pub fn update_collective_influence(
+    mut utilities_query: Query<(Entity, &Transform, &mut ContextAwareUtilities)>,
+    relations_query: Query<&SocialRelation>,
+    positions_query: Query<&Transform, Without<ContextAwareUtilities>>,
+) {
+    const MAX_INFLUENCE_DISTANCE: f32 = 100.0; // Universal influence range
+
+    for (entity, transform, mut utilities) in &mut utilities_query {
+        let mut total_collective_influence = 0.0;
+        let position = transform.translation.truncate();
+
+        // Get all social relations for this entity
+        for relation in relations_query.iter() {
+            if relation.target == entity {
+                continue; // Skip self-relations
+            }
+
+            // Calculate proximity influence from this relation
+            if let Ok(target_transform) = positions_query.get(relation.target) {
+                let target_pos = target_transform.translation.truncate();
+                let distance = position.distance(target_pos);
+
+                if distance <= MAX_INFLUENCE_DISTANCE {
+                    let proximity_influence =
+                        relation.proximity_utility_modifier(MAX_INFLUENCE_DISTANCE);
+                    total_collective_influence += proximity_influence;
+                }
+            }
+        }
+
+        // Update collective influence (clamped to reasonable range)
+        utilities.collective_influence = UtilityScore::new(total_collective_influence.min(1.0));
+    }
+}
+
+fn calculate_contextual_resource_competition(
+    personality: &Personality,
+    energy_level: f32,
+    recent_success: f32,
+) -> UtilityScore {
+    let energy_multiplier = 1.0 + (1.0 - energy_level) * 0.5;
+    let confidence_modifier = 1.0 + recent_success.clamp(-0.3, 0.3);
+
+    // SYSTEMIC AI: Add trait interdependency to calculations
+    let stress_influence = 1.0 + (personality.stress_tolerance - 0.5) * 0.2;
+    let competitive_influence = 1.0 + personality.competitive_strength * 0.15;
+
+    let base = personality.resource_competition_likelihood();
+    let result =
+        base * energy_multiplier * confidence_modifier * stress_influence * competitive_influence;
+
+    UtilityScore::new(result)
+}
+
+fn calculate_contextual_competitive_strength(
+    personality: &Personality,
+    energy_level: f32,
+    recent_success: f32,
+) -> UtilityScore {
+    let energy_threshold = if energy_level > 0.3 {
+        energy_level
+    } else {
+        energy_level * 0.5
+    };
+    let success_boost = 1.0 + recent_success.clamp(0.0, 0.4);
+
+    UtilityScore::new(personality.competitive_strength * energy_threshold * success_boost)
+}
+
+fn calculate_contextual_stress_retreat(
+    personality: &Personality,
+    energy_level: f32,
+    environmental_stress: f32,
+) -> UtilityScore {
+    let energy_modifier = 1.0 + (1.0 - energy_level) * 0.4;
+    let stress_modifier = 1.0 + environmental_stress * 0.6;
+
+    let base = personality.stress_retreat_likelihood();
+    UtilityScore::new(base * energy_modifier * stress_modifier)
+}
diff --git a/crates/systems/ai/src/relationships/mod.rs b/crates/systems/ai/src/relationships/mod.rs
index b4d43ac6..c7bfbaf9 100644
--- a/crates/systems/ai/src/relationships/mod.rs
+++ b/crates/systems/ai/src/relationships/mod.rs
@@ -1,9 +1,28 @@
 pub mod social;
 
+use bevy::prelude::*;
+
+/// Plugin for social relationship systems
+#[derive(Default)]
+pub struct SocialPlugin;
+
+impl Plugin for SocialPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<social::SocialNetwork>()
+            .register_type::<social::RelationshipStrength>()
+            .register_type::<social::RelationshipType>()
+            .register_type::<social::EntityRelationship>()
+            .register_type::<social::SocialRelation>();
+    }
+}
+
 /// Prelude for the relationships module.
 ///
 /// This includes social relationships and network components.
 pub mod prelude {
-    pub use crate::relationships::social::{SocialNetwork, RelationshipType, RelationshipStrength, 
-                                         EntityRelationship, get_relationship_strength};
-}
\ No newline at end of file
+    pub use crate::relationships::social::{
+        get_relationship_strength, EntityRelationship, RelationshipStrength, RelationshipType,
+        SocialNetwork, SocialRelation,
+    };
+    pub use crate::relationships::SocialPlugin;
+}
diff --git a/crates/systems/ai/src/relationships/social.rs b/crates/systems/ai/src/relationships/social.rs
index cae9fc3d..744f9705 100644
--- a/crates/systems/ai/src/relationships/social.rs
+++ b/crates/systems/ai/src/relationships/social.rs
@@ -1,50 +1,50 @@
-use bevy::prelude::*;
 use crate::prelude::*;
+use bevy::prelude::*;
 use std::collections::HashMap;
 
 /// Entity identifier type (compatible with Bevy ECS)
 pub type EntityId = Entity;
 
 /// Normalized relationship value between entities
-#[derive(Debug, Clone, Copy, Component)]
+#[derive(Debug, Clone, Copy, Component, Reflect)]
 pub struct RelationshipStrength(f32);
 
 impl RelationshipStrength {
-   pub fn new(value: f32) -> Self {
-       Self(value.clamp(0.0, 1.0))
-   }
-   
-   pub fn value(&self) -> f32 {
-       self.0
-   }
-   
-   /// Convert relationship to utility score for decision-making
-   pub fn to_utility(&self) -> UtilityScore {
-       UtilityScore::new(self.0)
-   }
-   
-   /// Modify relationship by amount (can be positive or negative)
-   pub fn adjust(&mut self, amount: f32) {
-       self.0 = (self.0 + amount).clamp(0.0, 1.0);
-   }
+    pub fn new(value: f32) -> Self {
+        Self(value.clamp(0.0, 1.0))
+    }
+
+    pub fn value(&self) -> f32 {
+        self.0
+    }
+
+    /// Convert relationship to utility score for decision-making
+    pub fn to_utility(&self) -> UtilityScore {
+        UtilityScore::new(self.0)
+    }
+
+    /// Modify relationship by amount (can be positive or negative)
+    pub fn adjust(&mut self, amount: f32) {
+        self.0 = (self.0 + amount).clamp(0.0, 1.0);
+    }
 }
 
 /// Core ecological relationship types
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Component)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Component, Reflect)]
 pub enum RelationshipType {
-   Cooperation,  // Mutual benefit
-   Competition,  // Resource rivals
-   Predation,    // Hunter/prey dynamics
-   Fear,         // Threat response
-   Kinship,      // Family/genetic bonds
+    Cooperation, // Mutual benefit
+    Competition, // Resource rivals
+    Predation,   // Hunter/prey dynamics
+    Fear,        // Threat response
+    Kinship,     // Family/genetic bonds
 }
 
 /// Single relationship between two entities
-#[derive(Debug, Clone, Component)]
+#[derive(Debug, Clone, Component, Reflect)]
 pub struct EntityRelationship {
-   pub strength: RelationshipStrength,
-   pub relationship_type: RelationshipType,
-   pub last_interaction_tick: u64, // Game ticks since last interaction
+    pub strength: RelationshipStrength,
+    pub relationship_type: RelationshipType,
+    pub last_interaction_tick: u64, // Game ticks since last interaction
 }
 
 impl EntityRelationship {
@@ -55,120 +55,127 @@ impl EntityRelationship {
 }
 
 /// Component that stores all relationships an entity maintains
-#[derive(Debug, Default, Component)]
+#[derive(Debug, Default, Component, Reflect)]
 pub struct SocialNetwork {
-   relationships: HashMap<EntityId, HashMap<RelationshipType, EntityRelationship>>,
+    relationships: HashMap<EntityId, HashMap<RelationshipType, EntityRelationship>>,
 }
 
 impl SocialNetwork {
-   /// Add a new relationship or update an existing one
-   pub fn add_or_update_relationship(&mut self, target: EntityId, relationship_type: RelationshipType, strength: f32, current_tick: u64) {
-       let mut relationship = EntityRelationship {
-           strength: RelationshipStrength::new(strength),
-           relationship_type,
-           last_interaction_tick: current_tick,
-       };
-
-       // If relationship already exists, update based on existing interaction history
-       if let Some(existing_relationship) = self.relationships
-           .entry(target)
-           .or_default()
-           .get_mut(&relationship_type) {
-           
-           // Modify strength based on interaction frequency
-           relationship.strength.adjust(
-               (current_tick - existing_relationship.last_interaction_tick) as f32 / 1000.0
-           );
-       }
-
-       self.relationships
-           .entry(target)
-           .or_default()
-           .insert(relationship_type, relationship);
-   }
-
-   /// Query relationships with flexible filtering
-   pub fn query_relationships(
-       &self, 
-       relationship_type: Option<RelationshipType>, 
-       min_strength: Option<f32>
-   ) -> Vec<(EntityId, &EntityRelationship)> {
-       let mut result = Vec::new();
-       
-       for (&entity_id, relationships) in &self.relationships {
-           for (current_type, relationship) in relationships {
-               let type_match = relationship_type.map_or(true, |rt| *current_type == rt);
-               let strength_match = min_strength.map_or(true, |ms| relationship.strength.value() >= ms);
-               
-               if type_match && strength_match {
-                   result.push((entity_id, relationship));
-               }
-           }
-       }
-       
-       result
-   }
-   
-   /// Adjust relationship based on personality traits
-   pub fn adjust_relationship_with_personality(
-       &mut self, 
-       target: EntityId, 
-       relationship_type: RelationshipType, 
-       personality: &Personality, 
-       current_tick: u64
-   ) {
-       // Base strength from existing relationship or default
-       let base_strength = self.relationships
-           .get(&target)
-           .and_then(|r| r.get(&relationship_type))
-           .map_or(0.5, |rel| rel.strength.value());
-       
-       // Apply personality modifiers
-       let modified_strength = match relationship_type {
-           RelationshipType::Cooperation => {
-               // More dominant personalities are less cooperative
-               base_strength * (1.0 - personality.dominance * 0.3)
-           },
-           RelationshipType::Competition => {
-               // More aggressive personalities compete more strongly
-               base_strength * (1.0 + personality.aggression * 0.5)
-           },
-           RelationshipType::Predation => {
-               // More aggressive and brave personalities have stronger predation
-               base_strength * (1.0 + personality.aggression * 0.6 + personality.bravery * 0.4)
-           },
-           RelationshipType::Fear => {
-               // Less brave personalities feel more fear
-               base_strength * (1.0 + (1.0 - personality.bravery) * 0.7)
-           },
-           RelationshipType::Kinship => {
-               // Personality doesn't strongly affect genetic relationships
-               base_strength
-           }
-       };
-       
-       // Add or update the relationship with the modified strength
-       self.add_or_update_relationship(
-           target, 
-           relationship_type, 
-           modified_strength, 
-           current_tick
-       );
-   }
+    /// Add a new relationship or update an existing one
+    pub fn add_or_update_relationship(
+        &mut self,
+        target: EntityId,
+        relationship_type: RelationshipType,
+        strength: f32,
+        current_tick: u64,
+    ) {
+        let mut relationship = EntityRelationship {
+            strength: RelationshipStrength::new(strength),
+            relationship_type,
+            last_interaction_tick: current_tick,
+        };
+
+        // If relationship already exists, update based on existing interaction history
+        if let Some(existing_relationship) = self
+            .relationships
+            .entry(target)
+            .or_default()
+            .get_mut(&relationship_type)
+        {
+            // Modify strength based on interaction frequency
+            relationship.strength.adjust(
+                (current_tick - existing_relationship.last_interaction_tick) as f32 / 1000.0,
+            );
+        }
+
+        self.relationships
+            .entry(target)
+            .or_default()
+            .insert(relationship_type, relationship);
+    }
+
+    /// Query relationships with flexible filtering
+    pub fn query_relationships(
+        &self,
+        relationship_type: Option<RelationshipType>,
+        min_strength: Option<f32>,
+    ) -> Vec<(EntityId, &EntityRelationship)> {
+        let mut result = Vec::new();
+
+        for (&entity_id, relationships) in &self.relationships {
+            for (current_type, relationship) in relationships {
+                let type_match = relationship_type.is_none_or(|rt| *current_type == rt);
+                let strength_match =
+                    min_strength.is_none_or(|ms| relationship.strength.value() >= ms);
+
+                if type_match && strength_match {
+                    result.push((entity_id, relationship));
+                }
+            }
+        }
+
+        result
+    }
+
+    /// Adjust relationship based on personality traits
+    pub fn adjust_relationship_with_personality(
+        &mut self,
+        target: EntityId,
+        relationship_type: RelationshipType,
+        personality: &Personality,
+        current_tick: u64,
+    ) {
+        // Base strength from existing relationship or default
+        let base_strength = self
+            .relationships
+            .get(&target)
+            .and_then(|r| r.get(&relationship_type))
+            .map_or(0.5, |rel| rel.strength.value());
+
+        // Apply personality modifiers
+        let modified_strength = match relationship_type {
+            RelationshipType::Cooperation => {
+                // More competitive personalities are less cooperative
+                base_strength * (1.0 - personality.competitive_strength * 0.3)
+            }
+            RelationshipType::Competition => {
+                // More resource assertive personalities compete more strongly
+                base_strength * (1.0 + personality.resource_assertiveness * 0.5)
+            }
+            RelationshipType::Predation => {
+                // More assertive and competitive personalities have stronger predation
+                base_strength
+                    * (1.0
+                        + personality.resource_assertiveness * 0.6
+                        + personality.competitive_strength * 0.4)
+            }
+            RelationshipType::Fear => {
+                // Less stress tolerant personalities feel more fear
+                base_strength * (1.0 + (1.0 - personality.stress_tolerance) * 0.7)
+            }
+            RelationshipType::Kinship => {
+                // Personality doesn't strongly affect genetic relationships
+                base_strength
+            }
+        };
+
+        // Add or update the relationship with the modified strength
+        self.add_or_update_relationship(target, relationship_type, modified_strength, current_tick);
+    }
 }
 
 /// Get social behavior utility score
 pub fn social_behavior_utility(relationships: &SocialNetwork) -> UtilityScore {
     let mut total_utility = 0.0;
     let mut count = 0;
-    
-    for (_, relationship_map) in &relationships.relationships {
-        for (_, relationship) in relationship_map {
+
+    for relationship_map in relationships.relationships.values() {
+        for relationship in relationship_map.values() {
             total_utility += relationship.strength.value();
             count += 1;
         }
     }
-    
+
     if count > 0 {
         UtilityScore::new(total_utility / count as f32)
     } else {
@@ -180,23 +187,59 @@ pub fn social_behavior_utility(relationships: &SocialNetwork) -> UtilityScore {
 pub fn get_relationship_strength(
     social_network: &SocialNetwork,
     target: EntityId,
-    relationship_type: RelationshipType
+    relationship_type: RelationshipType,
 ) -> Option<RelationshipStrength> {
-    social_network.relationships
+    social_network
+        .relationships
         .get(&target)
         .and_then(|relationships| relationships.get(&relationship_type))
         .map(|relationship| relationship.strength)
 }
 
-// In relationships/social.rs
 impl AIModule for SocialNetwork {
     fn update(&mut self) {
         // In a real implementation, this would decay old relationships
         // or update based on recent interactions
     }
-    
+
     fn utility(&self) -> UtilityScore {
         // Calculate overall social interaction utility
         social_behavior_utility(self)
     }
-}
\ No newline at end of file
+}
+
+// Optional Relations-based components (alternative to HashMap approach)
+#[derive(Component, Debug, Clone, Reflect)]
+pub struct SocialRelation {
+    pub target: Entity,
+    pub strength: RelationshipStrength,
+    pub relationship_type: RelationshipType,
+    pub last_interaction_tick: u64,
+    /// Spatial distance when relationship was last updated (for proximity influence)
+    pub last_distance: Option<f32>,
+}
+
+impl SocialRelation {
+    /// Adjust relationship strength based on spatial proximity
+    /// Closer entities have stronger social bonds (universal for all life)
+    pub fn update_with_proximity(&mut self, current_distance: f32, proximity_influence: f32) {
+        if let Some(last_dist) = self.last_distance {
+            // Getting closer strengthens bonds, getting farther weakens them
+            let distance_change = last_dist - current_distance;
+            let proximity_modifier = distance_change * proximity_influence * 0.01;
+            self.strength.adjust(proximity_modifier);
+        }
+        self.last_distance = Some(current_distance);
+    }
+
+    /// Calculate collective utility influence from nearby entities
+    /// Used for swarm intelligence patterns - closer entities have more influence
+    pub fn proximity_utility_modifier(&self, max_influence_distance: f32) -> f32 {
+        if let Some(distance) = self.last_distance {
+            let proximity_factor = (max_influence_distance - distance) / max_influence_distance;
+            proximity_factor.max(0.0) * self.strength.value()
+        } else {
+            0.0
+        }
+    }
+}
diff --git a/crates/systems/ai/src/trackers/base_tracker.rs b/crates/systems/ai/src/trackers/base_tracker.rs
index 545fd614..8ecc0401 100644
--- a/crates/systems/ai/src/trackers/base_tracker.rs
+++ b/crates/systems/ai/src/trackers/base_tracker.rs
@@ -1,8 +1,9 @@
-use bevy::prelude::*;
 use crate::prelude::*;
+use bevy::prelude::*;
 use std::collections::HashMap;
 
 /// Core tracker for monitoring entities
+#[derive(Component)]
 pub struct EntityTracker {
     /// Entities being tracked
     tracked_entities: HashMap<Entity, TrackedEntity>,
@@ -30,24 +31,26 @@ impl AIModule for EntityTracker {
         for tracked in self.tracked_entities.values_mut() {
             if !tracked.visual_contact {
                 tracked.ticks_since_seen += 1;
-                
+
                 // Reduce importance over time when not seen
                 if tracked.ticks_since_seen > 10 {
                     tracked.importance *= 0.99;
                 }
             }
         }
-        
+
         // Calculate priority based on most important tracked entity
-        self.priority = self.tracked_entities.values()
+        self.priority = self
+            .tracked_entities
+            .values()
             .map(|entity| entity.importance)
             .fold(0.0, f32::max);
-            
+
         // Remove low importance entities when over capacity
         if self.tracked_entities.len() > self.max_tracked_entities {
             let mut entries: Vec<_> = self.tracked_entities.iter().collect();
             entries.sort_by(|a, b| b.1.importance.partial_cmp(&a.1.importance).unwrap());
-            
+
             let cutoff = entries[self.max_tracked_entities].1.importance;
             self.tracked_entities.retain(|_, e| e.importance > cutoff);
         }
@@ -66,16 +69,19 @@ impl EntityTracker {
             priority: 0.0,
         }
     }
-    
+
     pub fn add_entity(&mut self, entity: Entity, position: Vec2, importance: f32) {
-        self.tracked_entities.insert(entity, TrackedEntity {
-            last_seen_position: position,
-            visual_contact: true,
-            ticks_since_seen: 0,
-            importance: importance.clamp(0.0, 1.0),
-        });
+        self.tracked_entities.insert(
+            entity,
+            TrackedEntity {
+                last_seen_position: position,
+                visual_contact: true,
+                ticks_since_seen: 0,
+                importance: importance.clamp(0.0, 1.0),
+            },
+        );
     }
-    
+
     pub fn update_entity(&mut self, entity: Entity, position: Vec2) {
         if let Some(tracked) = self.tracked_entities.get_mut(&entity) {
             tracked.last_seen_position = position;
@@ -83,14 +89,25 @@ impl EntityTracker {
             tracked.ticks_since_seen = 0;
         }
     }
-    
+
     pub fn get_tracked_entity(&self, entity: Entity) -> Option<&TrackedEntity> {
         self.tracked_entities.get(&entity)
     }
-    
+
     pub fn get_most_important_entity(&self) -> Option<(Entity, &TrackedEntity)> {
-        self.tracked_entities.iter()
+        self.tracked_entities
+            .iter()
             .max_by(|a, b| a.1.importance.partial_cmp(&b.1.importance).unwrap())
             .map(|(e, data)| (*e, data))
     }
-}
\ No newline at end of file
+}
+
+// Optional Relations-based tracking component (alternative to HashMap approach)
+#[derive(Component, Debug, Clone)]
+pub struct TrackingRelation {
+    pub target: Entity,
+    pub last_seen_position: Vec2,
+    pub visual_contact: bool,
+    pub ticks_since_seen: u32,
+    pub importance: f32,
+}
diff --git a/crates/systems/ai/src/trackers/mod.rs b/crates/systems/ai/src/trackers/mod.rs
index 2ab96133..aa1e13bd 100644
--- a/crates/systems/ai/src/trackers/mod.rs
+++ b/crates/systems/ai/src/trackers/mod.rs
@@ -4,11 +4,25 @@ pub mod perception_tracker;
 
 //TODO soon: pub mod relationship_tracker;
 
+use bevy::prelude::*;
+
+/// Plugin for entity tracking systems
+#[derive(Default)]
+pub struct TrackerPlugin;
+
+impl Plugin for TrackerPlugin {
+    fn build(&self, _app: &mut App) {
+        // Simple plugin - just makes trackers available
+        // Systems will be added later when we have proper integration
+    }
+}
+
 /// Prelude for the trackers module.
 ///
 /// This includes the most common tracking components and systems.
 pub mod prelude {
-    pub use crate::trackers::perception_tracker::Perception;
+    pub use crate::trackers::base_tracker::{EntityTracker, TrackedEntity, TrackingRelation};
     pub use crate::trackers::needs_tracker::NeedsTracker;
-    pub use crate::trackers::base_tracker::{EntityTracker, TrackedEntity};
-}
\ No newline at end of file
+    pub use crate::trackers::perception_tracker::Perception;
+    pub use crate::trackers::TrackerPlugin;
+}
diff --git a/crates/systems/ai/src/trackers/needs_tracker.rs b/crates/systems/ai/src/trackers/needs_tracker.rs
index b096f2a0..0d5ee5ea 100644
--- a/crates/systems/ai/src/trackers/needs_tracker.rs
+++ b/crates/systems/ai/src/trackers/needs_tracker.rs
@@ -1,7 +1,8 @@
-///use bevy::prelude::*;
 use crate::prelude::*;
+use bevy::prelude::*;
 
 /// Tracks and manages needs for an entity
+#[derive(Component)]
 pub struct NeedsTracker {
     needs: Vec<Need>,
     most_urgent_need: Option<(NeedType, UtilityScore)>,
@@ -14,19 +15,21 @@ impl NeedsTracker {
             most_urgent_need: None,
         }
     }
-    
+
     pub fn add_need(&mut self, need: Need) {
         self.needs.push(need);
     }
-    
+
     pub fn get_needs(&self) -> &[Need] {
         &self.needs
     }
-    
+
     pub fn get_need_mut(&mut self, need_type: NeedType) -> Option<&mut Need> {
-        self.needs.iter_mut().find(|need| need.need_type == need_type)
+        self.needs
+            .iter_mut()
+            .find(|need| need.need_type == need_type)
     }
-    
+
     pub fn get_most_urgent_need(&self) -> Option<(NeedType, UtilityScore)> {
         self.most_urgent_need
     }
@@ -38,11 +41,11 @@ impl AIModule for NeedsTracker {
         for need in &mut self.needs {
             need.update();
         }
-        
+
         // Find most urgent need
         let mut most_urgent = None;
         let mut highest_urgency = UtilityScore::new(0.0);
-        
+
         for need in &self.needs {
             let urgency = need.urgency();
             if urgency.value() > highest_urgency.value() {
@@ -50,14 +53,14 @@ impl AIModule for NeedsTracker {
                 highest_urgency = urgency;
             }
         }
-        
+
         self.most_urgent_need = most_urgent.map(|need_type| (need_type, highest_urgency));
     }
-    
+
     fn utility(&self) -> UtilityScore {
         // Return the urgency of the most urgent need, or zero if no needs
         self.most_urgent_need
             .map(|(_, urgency)| urgency)
             .unwrap_or(UtilityScore::new(0.0))
     }
-}
\ No newline at end of file
+}
diff --git a/crates/systems/ai/src/trackers/perception_tracker.rs b/crates/systems/ai/src/trackers/perception_tracker.rs
index 75f24ae6..bc9b4988 100644
--- a/crates/systems/ai/src/trackers/perception_tracker.rs
+++ b/crates/systems/ai/src/trackers/perception_tracker.rs
@@ -1,6 +1,7 @@
-use bevy::prelude::*;
 use crate::prelude::*;
+use bevy::prelude::*;
 
+#[derive(Component)]
 pub struct Perception {
     pub visible_entities: Vec<(Entity, Vec2, f32)>, // Entity, position, distance
     pub detection_radius: f32,
@@ -10,19 +11,19 @@ pub struct Perception {
 
 impl Perception {
     pub fn new(detection_radius: f32) -> Self {
-        Self { 
+        Self {
             visible_entities: Vec::new(),
             detection_radius,
             last_updated: 0.0,
-            highest_threat_level: 0.0
+            highest_threat_level: 0.0,
         }
     }
-    
+
     pub fn update(&mut self, position: Vec2, entities: &[(Entity, Vec2)], time: f32) {
         self.visible_entities.clear();
         self.last_updated = time;
         self.highest_threat_level = 0.0;
-        
+
         for (entity, entity_pos) in entities {
             let distance = position.distance(*entity_pos);
             if distance <= self.detection_radius {
@@ -33,11 +34,15 @@ impl Perception {
             }
         }
     }
-    
+
     pub fn closest_entity(&self) -> Option<(Entity, Vec2, f32)> {
-        self.visible_entities.iter()
-            .min_by(|(_, _, dist_a), (_, _, dist_b)| 
-                dist_a.partial_cmp(dist_b).unwrap_or(std::cmp::Ordering::Equal))
+        self.visible_entities
+            .iter()
+            .min_by(|(_, _, dist_a), (_, _, dist_b)| {
+                dist_a
+                    .partial_cmp(dist_b)
+                    .unwrap_or(std::cmp::Ordering::Equal)
+            })
             .copied()
     }
 }
@@ -46,13 +51,13 @@ impl AIModule for Perception {
     fn update(&mut self) {
         // This would be called from controller - actual update happens in update() method
         // with position and entities data
-        
+
         // Decay threat level over time when not explicitly updated
         self.highest_threat_level *= 0.95;
     }
-    
+
     fn utility(&self) -> UtilityScore {
         // Return threat level as utility - higher threat means more important
         UtilityScore::new(self.highest_threat_level)
     }
-}
\ No newline at end of file
+}
diff --git a/crates/systems/pbmpm/src/grid.rs b/crates/systems/pbmpm/src/grid.rs
index e69de29b..8b137891 100644
--- a/crates/systems/pbmpm/src/grid.rs
+++ b/crates/systems/pbmpm/src/grid.rs
@@ -0,0 +1 @@
+
diff --git a/crates/systems/pbmpm/src/lib.rs b/crates/systems/pbmpm/src/lib.rs
index 3a3f8dfa..ff9ee32c 100644
--- a/crates/systems/pbmpm/src/lib.rs
+++ b/crates/systems/pbmpm/src/lib.rs
@@ -1,4 +1,30 @@
+use bevy::prelude::*;
+
 pub mod grid;
 pub mod particles;
 pub mod solver;
 pub mod transfer;
+
+/// Plugin for Point-Based Material Point Method physics solver
+#[derive(Default)]
+pub struct PBMPMPlugin;
+
+impl Plugin for PBMPMPlugin {
+    fn build(&self, _app: &mut App) {
+        // TODO: Will integrate PBMPM systems when implementation is ready
+        // Plugin structure prepared for upcoming development
+    }
+}
+
+/// The PBMPM prelude.
+///
+/// This includes the most common types in this crate, re-exported for your convenience.
+pub mod prelude {
+    pub use super::PBMPMPlugin;
+
+    // TODO: Export main types when implementation is complete
+    // pub use crate::grid::*;
+    // pub use crate::particles::*;
+    // pub use crate::solver::*;
+    // pub use crate::transfer::*;
+}
diff --git a/crates/systems/pbmpm/src/particles.rs b/crates/systems/pbmpm/src/particles.rs
index e69de29b..8b137891 100644
--- a/crates/systems/pbmpm/src/particles.rs
+++ b/crates/systems/pbmpm/src/particles.rs
@@ -0,0 +1 @@
+
diff --git a/crates/systems/pbmpm/src/solver.rs b/crates/systems/pbmpm/src/solver.rs
index e69de29b..8b137891 100644
--- a/crates/systems/pbmpm/src/solver.rs
+++ b/crates/systems/pbmpm/src/solver.rs
@@ -0,0 +1 @@
+
diff --git a/crates/systems/pbmpm/src/transfer.rs b/crates/systems/pbmpm/src/transfer.rs
index e69de29b..8b137891 100644
--- a/crates/systems/pbmpm/src/transfer.rs
+++ b/crates/systems/pbmpm/src/transfer.rs
@@ -0,0 +1 @@
+
diff --git a/crates/systems/save_system/src/lib.rs b/crates/systems/save_system/src/lib.rs
index 901605cd..9898993c 100644
--- a/crates/systems/save_system/src/lib.rs
+++ b/crates/systems/save_system/src/lib.rs
@@ -1,2 +1,22 @@
+use bevy::prelude::*;
+
 pub mod save_system;
 pub mod versioning;
+
+/// Plugin for save/load functionality with versioning support
+#[derive(Default)]
+pub struct SaveSystemPlugin;
+
+impl Plugin for SaveSystemPlugin {
+    fn build(&self, _app: &mut App) {
+        // TODO: Will add save/load systems when needed
+        // For now, just register the plugin
+    }
+}
+
+/// Prelude for easy importing
+pub mod prelude {
+    pub use super::SaveSystemPlugin;
+    pub use crate::save_system::{load, save};
+    pub use crate::versioning::{is_save_up_to_date, upgrade_save, SAVE_VERSION};
+}
diff --git a/crates/systems/save_system/src/versioning.rs b/crates/systems/save_system/src/versioning.rs
index 63ea38e4..b8356f77 100644
--- a/crates/systems/save_system/src/versioning.rs
+++ b/crates/systems/save_system/src/versioning.rs
@@ -9,7 +9,7 @@ pub fn is_save_up_to_date(data: &Value) -> bool {
         .and_then(|v| v.as_str())
         .unwrap_or("0.0.0")
         .to_string();
-    if version == SAVE_VERSION.to_string() {
+    if version == *SAVE_VERSION {
         return true;
     }
 
@@ -36,7 +36,7 @@ pub fn upgrade_save(mut data: Value) -> Value {
 
     // Ensure missing fields are initialized dynamically
     for (key, default_value) in get_default_fields() {
-        if !data.get(key).is_some() {
+        if data.get(key).is_none() {
             eprintln!("[Info] Adding missing field: {}", key);
             data[key] = default_value.clone(); // Ensure the value is actually added
         }
diff --git a/crates/systems/src/lib.rs b/crates/systems/src/lib.rs
index 3ada2d70..8d40daad 100644
--- a/crates/systems/src/lib.rs
+++ b/crates/systems/src/lib.rs
@@ -2,3 +2,33 @@ pub use acoustics;
 pub use ai;
 pub use pbmpm;
 pub use save_system;
+
+use bevy::prelude::*;
+
+/// Main plugin for all systems-related functionality  
+#[derive(Default)]
+pub struct SystemsPlugin;
+
+impl Plugin for SystemsPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((
+            acoustics::AcousticsPlugin,
+            ai::LPAIPlugin::default(),
+            pbmpm::PBMPMPlugin,
+            save_system::SaveSystemPlugin,
+        ));
+    }
+}
+
+/// The systems prelude.
+///
+/// This includes all system plugins for easy importing.
+pub mod prelude {
+    pub use super::SystemsPlugin;
+
+    // Re-export all sub-crate preludes
+    pub use acoustics::prelude::*;
+    pub use ai::prelude::*;
+    pub use pbmpm::prelude::*;
+    pub use save_system::prelude::*;
+}
diff --git a/examples/basic_ai.rs b/examples/basic_ai.rs
index cf780887..ff4c5332 100644
--- a/examples/basic_ai.rs
+++ b/examples/basic_ai.rs
@@ -4,14 +4,26 @@ use systems::ai::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
+        // Add our modular AI plugins
+        .add_plugins((
+            LPAIPlugin::default(), // Core utility AI framework
+            SocialPlugin,          // Social relationship system
+            TrackerPlugin,         // Entity tracking system
+            DrivesPlugin,          // Biological drives system
+            PersonalityPlugin,     // Personality and behavioral traits
+        ))
         .insert_resource(ClearColor(Color::srgb(0.1, 0.1, 0.15)))
         .add_systems(Startup, setup)
-        .add_systems(Update, (
-            update_creatures_and_perception,
-            handle_food_consumption,
-            respawn_food,
-            update_visuals
-        ))
+        .add_systems(
+            Update,
+            (
+                update_creatures_and_perception,
+                handle_food_consumption,
+                respawn_food,
+                update_visuals,
+                update_personality_labels,
+            ),
+        )
         .run();
 }
 
@@ -24,15 +36,12 @@ struct CreatureAction {
 
 #[derive(Component)]
 struct Creature {
-    social_network: SocialNetwork,
     perception: Perception,
     velocity: Vec2,
     lifespan: f32,
     hunger: f32,
     action: CreatureAction,
     using_concurrent_actions: bool,
-    // Simple field to track if this creature is altruistic
-    altruistic: bool,
 }
 
 #[derive(Component)]
@@ -41,42 +50,66 @@ struct Food {
     active: bool,
 }
 
+#[derive(Component)]
+struct CreatureLabel {
+    creature: Entity,
+}
+
 fn setup(mut commands: Commands) {
     commands.spawn(Camera2d);
-    
+
     // Spawn creatures
     for i in 0..8 {
         let x = ((i % 4) as f32 - 1.5) * 80.0;
         let y = (i as f32 / 4.0).floor() * 100.0 - 50.0;
-        
+
+        let entity = commands
+            .spawn((
+                Sprite {
+                    color: Color::srgb(0.2, 0.9, 0.2),
+                    custom_size: Some(Vec2::new(20.0, 20.0)),
+                    ..default()
+                },
+                Transform::from_translation(Vec3::new(x, y, 0.0)),
+                Visibility::default(),
+                Creature {
+                    perception: Perception::new(200.0),
+                    velocity: Vec2::new(0.0, 0.0),
+                    lifespan: 30.0,
+                    hunger: 0.0,
+                    action: CreatureAction::default(),
+                    using_concurrent_actions: true,
+                },
+                // AI components - all start neutral, diverge through experience
+                Personality::default(),
+            ))
+            .id();
+
+        // Add dynamic state label text
         commands.spawn((
-            Sprite {
-                color: Color::srgb(0.2, 0.9, 0.2),
-                custom_size: Some(Vec2::new(20.0, 20.0)),
-                ..default()
-            },
-            Transform::from_translation(Vec3::new(x, y, 0.0)),
-            Visibility::default(),
-            Creature {
-                social_network: SocialNetwork::default(),
-                perception: Perception::new(200.0),
-                velocity: Vec2::new(0.0, 0.0),
-                lifespan: 30.0,
-                hunger: 0.0,
-                action: CreatureAction::default(),
-                using_concurrent_actions: true,
-                // Enable altruism for creatures with odd indices
-                altruistic: i % 2 == 1,
-            },
+            Text2d::new("Neutral"),
+            TextLayout::new_with_justify(JustifyText::Center),
+            Transform::from_translation(Vec3::new(x, y + 25.0, 1.0)).with_scale(Vec3::splat(0.5)), // Half the size
+            CreatureLabel { creature: entity },
         ));
+
+        let mut entity_commands = commands.entity(entity);
+
+        // Add varied personality starting points and components
+        if i % 2 == 1 {
+            entity_commands.insert(Altruistic::default());
+        }
+
+        // Add context-aware utilities component to enable physics-based decision making
+        entity_commands.insert(ContextAwareUtilities::default());
     }
-    
+
     // Spawn food patches
     for i in 0..4 {
         for j in 0..4 {
             let x = (i as f32 - 1.5) * 120.0;
             let y = (j as f32 - 1.5) * 80.0;
-            
+
             commands.spawn((
                 Sprite {
                     color: Color::srgb(0.0, 0.5, 0.0),
@@ -97,110 +130,102 @@ fn setup(mut commands: Commands) {
 fn update_creatures_and_perception(
     mut commands: Commands,
     mut params: ParamSet<(
-        Query<(Entity, &mut Transform, &mut Creature)>,
+        Query<(
+            Entity,
+            &mut Transform,
+            &mut Creature,
+            Option<&Altruistic>,
+            &Personality,
+        )>,
         Query<(Entity, &Transform, &Food)>,
     )>,
     time: Res<Time>,
 ) {
     // Get food info first
-    let food_entities: Vec<(Entity, Vec3, bool)> = params.p1()
+    let food_entities: Vec<(Entity, Vec3, bool)> = params
+        .p1()
         .iter()
         .map(|(e, t, f)| (e, t.translation, f.active))
         .collect();
-    
+
     let active_food: Vec<(Entity, Vec3)> = food_entities
         .iter()
         .filter(|(_, _, active)| *active)
         .map(|(e, pos, _)| (*e, *pos))
         .collect();
-        
+
     // Get a list of creatures and their positions first for altruistic behavior
-    let creatures: Vec<(Entity, Vec2, f32)> = {
+    let creatures: Vec<(Entity, Vec2, f32, bool)> = {
         let query = params.p0();
-        query.iter()
-            .map(|(entity, transform, creature)| (
-                entity, 
-                transform.translation.truncate(),
-                creature.hunger
-            ))
+        query
+            .iter()
+            .map(|(entity, transform, creature, altruistic, _)| {
+                (
+                    entity,
+                    transform.translation.truncate(),
+                    creature.hunger,
+                    altruistic.is_some(),
+                )
+            })
             .collect()
     };
-    
+
     // Update perception and calculate movements
     let mut velocities = Vec::new();
     let mut to_despawn = Vec::new();
-    
+
     {
         let mut query = params.p0();
-        
-        for (entity, transform, mut creature) in query.iter_mut() {
+
+        for (entity, transform, mut creature, altruistic, personality) in query.iter_mut() {
             // First update perception
             let position = transform.translation.truncate();
-            
+
             let food_for_perception: Vec<(Entity, Vec2)> = active_food
                 .iter()
                 .map(|(e, pos)| (*e, pos.truncate()))
                 .collect();
-            
-            creature.perception.update(
-                position,
-                &food_for_perception,
-                time.elapsed_secs()
-            );
-            
-            // Update relationships
-            let hunger = creature.hunger;
+
+            creature
+                .perception
+                .update(position, &food_for_perception, time.elapsed_secs());
+
+            // Update relationships using Relations system
             let current_tick = (time.elapsed_secs() * 10.0) as u64;
-            
+
             for (food_entity, _) in &food_for_perception {
-                creature.social_network.add_or_update_relationship(
-                    *food_entity,
-                    RelationshipType::Cooperation,
-                    0.8 + hunger * 0.2,
-                    current_tick
-                );
+                // Add cooperation relationship using Relations
+                commands.entity(entity).insert(SocialRelation {
+                    target: *food_entity,
+                    strength: RelationshipStrength::new(0.8 + creature.hunger * 0.2),
+                    relationship_type: RelationshipType::Cooperation,
+                    last_interaction_tick: current_tick,
+                    last_distance: None,
+                });
             }
-            
+
             // Update lifespan and hunger with action tracking
             creature.lifespan -= time.delta_secs();
             creature.hunger = (creature.hunger + time.delta_secs() * 0.1).min(1.0);
             creature.action.action_attempts += 1;
-            
+
             // Despawn if lifespan expires or hunger reaches maximum
             if creature.lifespan <= 0.0 || creature.hunger >= 1.0 {
                 to_despawn.push(entity);
                 continue;
             }
-            
+
             // Movement logic
             let mut movement = Vec2::ZERO;
-            
+
             if creature.hunger > 0.3 && !active_food.is_empty() {
                 if creature.using_concurrent_actions {
-                    // Strategy 1: Social-based approach (existing logic)
-                    let mut social_target = None;
-                    let mut social_score = 0.0;
-                    let food_relationships = creature.social_network.query_relationships(
-                        Some(RelationshipType::Cooperation),
-                        Some(0.5)
-                    );
-                    
-                    for (food_entity, relation) in &food_relationships {
-                        if let Some((_, food_pos)) = active_food.iter().find(|(e, _)| e == food_entity) {
-                            let dist = position.distance(food_pos.truncate());
-                            let score = relation.strength.value() * (1.0 - dist / 400.0);
-                            
-                            if score > social_score {
-                                social_score = score;
-                                social_target = Some(food_pos.truncate());
-                            }
-                        }
-                    }
-                    
+                    // Future: Relations-based social approach will go here
+
                     // Strategy 2: Direct distance-based approach
-                    let mut direct_target = None;
+                    let mut direct_target: Option<Vec2> = None;
                     let mut closest_dist = f32::MAX;
-                    
+
                     for (_, food_pos) in &active_food {
                         let dist = position.distance(food_pos.truncate());
                         if dist < closest_dist {
@@ -208,115 +233,102 @@ fn update_creatures_and_perception(
                             direct_target = Some(food_pos.truncate());
                         }
                     }
-                    
-                    // Simple altruistic behavior - if this creature is altruistic and not too hungry,
-                    // check if other creatures are closer to the target food and hungrier
-                    if creature.altruistic && creature.hunger < 0.7 {
-                        if let Some(target_pos) = direct_target {
-                            for (other_entity, other_pos, other_hunger) in &creatures {
-                                if *other_entity != entity {
-                                    let other_distance = other_pos.distance(target_pos);
-                                    let self_distance = position.distance(target_pos);
-                                    
-                                    // If another creature is closer and hungrier, look for a different food
-                                    if other_distance < self_distance && *other_hunger > creature.hunger + 0.2 {
-                                        // Find alternative food
-                                        let mut alternative = None;
-                                        let mut alt_dist = f32::MAX;
-                                        
-                                        for (_, food_pos) in &active_food {
-                                            let fp = food_pos.truncate();
-                                            if fp.distance(target_pos) > 50.0 { // Different food
-                                                let dist = position.distance(fp);
-                                                if dist < alt_dist {
-                                                    alt_dist = dist;
-                                                    alternative = Some(fp);
+
+                    // Altruistic behavior using Altruistic component
+                    if let Some(altruistic_trait) = altruistic {
+                        if altruistic_trait.should_be_altruistic(creature.hunger) {
+                            if let Some(target_pos) = direct_target {
+                                for (other_entity, other_pos, other_hunger, _) in &creatures {
+                                    if *other_entity != entity {
+                                        let other_distance = other_pos.distance(target_pos);
+                                        let self_distance = position.distance(target_pos);
+
+                                        // If another creature is closer and hungrier, look for a different food
+                                        if other_distance < self_distance
+                                            && *other_hunger > creature.hunger + 0.2
+                                        {
+                                            // Find alternative food
+                                            let mut alternative = None;
+                                            let mut alt_dist = f32::MAX;
+
+                                            for (_, food_pos) in &active_food {
+                                                let fp = food_pos.truncate();
+                                                if fp.distance(target_pos) > 50.0 {
+                                                    // Different food
+                                                    let dist = position.distance(fp);
+                                                    if dist < alt_dist {
+                                                        alt_dist = dist;
+                                                        alternative = Some(fp);
+                                                    }
                                                 }
                                             }
+
+                                            if let Some(alt_pos) = alternative {
+                                                direct_target = Some(alt_pos);
+                                                // Add positive relationship with the creature we helped using Relations
+                                                commands.entity(entity).insert(SocialRelation {
+                                                    target: *other_entity,
+                                                    strength: RelationshipStrength::new(0.9),
+                                                    relationship_type:
+                                                        RelationshipType::Cooperation,
+                                                    last_interaction_tick: current_tick,
+                                                    last_distance: None,
+                                                });
+                                            }
+                                            break;
                                         }
-                                        
-                                        if let Some(alt_pos) = alternative {
-                                            direct_target = Some(alt_pos);
-                                            closest_dist = alt_dist;
-                                            // Add positive relationship with the creature we helped
-                                            creature.social_network.add_or_update_relationship(
-                                                *other_entity,
-                                                RelationshipType::Cooperation,
-                                                0.9, // Strong cooperative relationship
-                                                current_tick
-                                            );
-                                        }
-                                        break;
                                     }
                                 }
                             }
                         }
                     }
-                    
-                    // Race mode: Use the strategy with higher score
-                    let social_value = social_score;
-                    let direct_value = if closest_dist < f32::MAX { 1.0 - (closest_dist / 500.0) } else { 0.0 };
-                    
-                    if social_value > direct_value && social_target.is_some() {
-                        let food_pos = social_target.unwrap();
-                        let direction = (food_pos - position).normalize_or_zero();
-                        movement = direction * (40.0 + 30.0 * creature.hunger);
-                    } else if direct_target.is_some() {
+
+                    // Use direct distance approach (Relations queries will be added in future systems)
+                    if direct_target.is_some() {
                         let food_pos = direct_target.unwrap();
                         let direction = (food_pos - position).normalize_or_zero();
-                        movement = direction * (40.0 + 30.0 * creature.hunger);
+
+                        // Movement speed influenced by evolved personality traits
+                        let base_speed = 30.0;
+                        let hunger_urgency = creature.hunger * 25.0;
+                        let assertiveness_boost = personality.resource_assertiveness * 15.0;
+                        let stress_modifier = 1.0 + (1.0 - personality.stress_tolerance) * 0.3;
+                        let total_speed =
+                            (base_speed + hunger_urgency + assertiveness_boost) * stress_modifier;
+
+                        movement = direction * total_speed;
                     }
                 } else {
-                    // Original single-strategy logic
-                    let food_relationships = creature.social_network.query_relationships(
-                        Some(RelationshipType::Cooperation),
-                        Some(0.5)
-                    );
-                    
-                    let mut target_food = None;
-                    let mut best_score = 0.0;
-                    
-                    for (food_entity, relation) in &food_relationships {
-                        if let Some((_, food_pos)) = active_food.iter().find(|(e, _)| e == food_entity) {
-                            let dist = position.distance(food_pos.truncate());
-                            let score = relation.strength.value() * (1.0 - dist / 400.0);
-                            
-                            if score > best_score {
-                                best_score = score;
-                                target_food = Some(food_pos.truncate());
-                            }
-                        }
-                    }
-                    
-                    if let Some(food_pos) = target_food {
-                        let direction = (food_pos - position).normalize_or_zero();
+                    // Simplified single-strategy logic - direct approach to nearest food
+                    if let Some((_, food_pos)) = active_food.first() {
+                        let direction = (food_pos.truncate() - position).normalize_or_zero();
                         movement = direction * (40.0 + 30.0 * creature.hunger);
                     }
                 }
             }
-            
+
             // Add random movement if not seeking food
             if movement.length() < 5.0 {
                 let t = time.elapsed_secs() + transform.translation.x * 0.01;
                 movement = Vec2::new(t.sin() * 15.0, t.cos() * 15.0);
             }
-            
+
             // Apply velocity with smoothing
             creature.velocity = creature.velocity.lerp(movement, 0.2);
             velocities.push((entity, creature.velocity));
         }
     }
-    
+
     // Apply movement in a separate query to avoid multiple mutable borrows
     {
         let mut query = params.p0();
-        
+
         for (entity_id, velocity) in velocities {
-            if let Ok((_, mut transform, _)) = query.get_mut(entity_id) {
+            if let Ok((_, mut transform, _, _, _)) = query.get_mut(entity_id) {
                 // Update position
                 transform.translation.x += velocity.x * time.delta_secs();
                 transform.translation.y += velocity.y * time.delta_secs();
-                
+
                 // Keep within bounds
                 let bounds = Vec2::new(300.0, 200.0);
                 if transform.translation.x.abs() > bounds.x {
@@ -328,7 +340,7 @@ fn update_creatures_and_perception(
             }
         }
     }
-    
+
     // Despawn entities with expired lifespan
     for entity in to_despawn {
         commands.entity(entity).despawn();
@@ -336,26 +348,47 @@ fn update_creatures_and_perception(
 }
 
 fn handle_food_consumption(
-    mut creature_query: Query<(&Transform, &mut Creature)>,
+    mut creature_query: Query<(&Transform, &mut Creature, &mut Personality)>,
     mut food_query: Query<(Entity, &Transform, &mut Food, &mut Visibility)>,
 ) {
-    for (creature_transform, mut creature) in creature_query.iter_mut() {
+    for (creature_transform, mut creature, mut personality) in creature_query.iter_mut() {
         let creature_pos = creature_transform.translation.truncate();
-        
+
         for (_, food_transform, mut food, mut visibility) in food_query.iter_mut() {
             if !food.active {
                 continue;
             }
-            
+
             let food_pos = food_transform.translation.truncate();
             let distance = creature_pos.distance(food_pos);
-            
+
             if distance < 25.0 {
                 creature.lifespan = (creature.lifespan + 15.0).min(30.0);
                 creature.hunger = 0.0;
                 creature.action.total_food_consumed += 1;
                 creature.action.last_action_result = ActionState::Success;
-                
+
+                // SUCCESS = PERSONALITY EVOLUTION! Less hardcoded, more emergent
+                personality.resource_assertiveness =
+                    (personality.resource_assertiveness + 0.01).min(1.0);
+                personality.competitive_strength =
+                    (personality.competitive_strength + 0.005).min(1.0);
+
+                // SYSTEMIC AI: Traits affect each other creating emergent behavior patterns
+                // Success builds confidence but also competitive drive
+                personality.stress_tolerance = (personality.stress_tolerance + 0.003).min(1.0);
+
+                // High assertiveness creates stress over time (aggressive behavior is taxing)
+                if personality.resource_assertiveness > 0.7 {
+                    personality.stress_tolerance = (personality.stress_tolerance - 0.001).max(0.0);
+                }
+
+                // Competitive strength influences assertiveness (winners become more bold)
+                if personality.competitive_strength > 0.6 {
+                    personality.resource_assertiveness =
+                        (personality.resource_assertiveness + 0.002).min(1.0);
+                }
+
                 food.active = false;
                 food.respawn_timer.reset();
                 *visibility = Visibility::Hidden;
@@ -365,14 +398,11 @@ fn handle_food_consumption(
     }
 }
 
-fn respawn_food(
-    mut food_query: Query<(&mut Food, &mut Visibility)>,
-    time: Res<Time>,
-) {
+fn respawn_food(mut food_query: Query<(&mut Food, &mut Visibility)>, time: Res<Time>) {
     for (mut food, mut visibility) in food_query.iter_mut() {
         if !food.active {
             food.respawn_timer.tick(time.delta());
-            
+
             if food.respawn_timer.finished() {
                 food.active = true;
                 *visibility = Visibility::Inherited;
@@ -381,26 +411,79 @@ fn respawn_food(
     }
 }
 
-fn update_visuals(
-    mut query: Query<(&Creature, &mut Sprite)>,
-) {
-    for (creature, mut sprite) in &mut query {
+fn update_visuals(mut query: Query<(&Creature, &mut Sprite, Option<&Altruistic>)>) {
+    for (creature, mut sprite, altruistic) in &mut query {
         // Base color based on hunger
         let mut red = 0.2 + creature.hunger * 0.6;
         let green = 0.9 - creature.hunger * 0.3;
-        
+
         // Base blue for concurrent actions
         let mut blue = 0.2;
         if creature.using_concurrent_actions {
             blue += 0.2;
         }
-        
+
         // Add purple tint for altruistic creatures
-        if creature.altruistic {
+        if altruistic.is_some() {
             red += 0.1;
             blue += 0.1;
         }
-        
+
         sprite.color = Color::srgb(red, green, blue);
     }
-}
\ No newline at end of file
+}
+
+fn update_personality_labels(
+    mut commands: Commands,
+    creature_query: Query<(
+        Entity,
+        &Personality,
+        &Creature,
+        &Transform,
+        Option<&Altruistic>,
+    )>,
+    mut label_query: Query<
+        (Entity, &mut Text2d, &mut Transform, &CreatureLabel),
+        Without<Creature>,
+    >,
+) {
+    for (label_entity, mut text, mut label_transform, label) in &mut label_query {
+        if let Ok((_, personality, creature, creature_transform, altruistic)) =
+            creature_query.get(label.creature)
+        {
+            // Update label position to follow creature
+            label_transform.translation.x = creature_transform.translation.x;
+            label_transform.translation.y = creature_transform.translation.y + 25.0;
+
+            // Core AI states showing emergent personality development
+            let state = if creature.hunger > 0.8 {
+                "Starving"
+            } else if creature.action.last_action_result == ActionState::Success
+                && altruistic.is_some()
+            {
+                "Altruistic"
+            } else if creature.hunger > 0.3 {
+                if personality.resource_assertiveness > 0.6 && personality.stress_tolerance < 0.4 {
+                    "Aggressive"
+                } else if personality.resource_assertiveness > 0.6 {
+                    "Competitive"
+                } else {
+                    "Seeking"
+                }
+            } else if personality.resource_assertiveness > 0.6
+                || personality.competitive_strength > 0.6
+            {
+                "Evolved"
+            } else if personality.stress_tolerance > 0.7 {
+                "Calm"
+            } else {
+                "Neutral"
+            };
+
+            **text = state.to_string();
+        } else {
+            // Creature died, despawn the label
+            commands.entity(label_entity).despawn();
+        }
+    }
+}
diff --git a/examples/basic_electromagnetism.rs b/examples/basic_electromagnetism.rs
index c288f1b7..a7904b05 100644
--- a/examples/basic_electromagnetism.rs
+++ b/examples/basic_electromagnetism.rs
@@ -62,7 +62,10 @@ fn update_field_lines(
 
     // Get charge position
     let charge_pos = if let Ok(charge_transform) = charge_query.single() {
-        Vec2::new(charge_transform.translation.x, charge_transform.translation.y)
+        Vec2::new(
+            charge_transform.translation.x,
+            charge_transform.translation.y,
+        )
     } else {
         Vec2::ZERO
     };
@@ -86,4 +89,4 @@ fn update_field_lines(
             sprite.custom_size = Some(Vec2::new(0.0, 0.0));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/examples/basic_forces.rs b/examples/basic_forces.rs
index 866be937..ae21dbb2 100644
--- a/examples/basic_forces.rs
+++ b/examples/basic_forces.rs
@@ -138,7 +138,7 @@ fn keep_in_bounds(windows: Query<&Window>, mut query: Query<(&mut Transform, &mu
     let Ok(window) = windows.single() else {
         return; // Exit early if we can't get the window
     };
-    
+
     let width = window.width();
     let height = window.height();
 
diff --git a/examples/basic_plant.rs b/examples/basic_plant.rs
index 43d4928b..ae0496fc 100644
--- a/examples/basic_plant.rs
+++ b/examples/basic_plant.rs
@@ -1,5 +1,5 @@
 use information::fractals::prelude::*;
-use rand::prelude::*; //Will move to bevy_rand 
+use rand::prelude::*; //Will move to bevy_rand
 
 fn main() {
     // Load the multi-symbol template from fractals.json
diff --git a/examples/basic_thermodynamics.rs b/examples/basic_thermodynamics.rs
index 40748d42..cf34ace5 100644
--- a/examples/basic_thermodynamics.rs
+++ b/examples/basic_thermodynamics.rs
@@ -92,14 +92,16 @@ fn handle_input(
         let Ok(window) = windows.single() else {
             return;
         };
-        
+
         if let Some(cursor_position) = window.cursor_position() {
             // Get camera components properly
             let Ok((camera, camera_transform)) = camera_q.single() else {
                 return;
             };
-            
-            if let Ok(world_position) = camera.viewport_to_world_2d(camera_transform, cursor_position) {
+
+            if let Ok(world_position) =
+                camera.viewport_to_world_2d(camera_transform, cursor_position)
+            {
                 for (_cell, mut temp, transform) in grid_cells.iter_mut() {
                     let cell_pos = transform.translation.truncate();
                     let half_size = CELL_SIZE / 2.0;