diff --git a/services/trading_service/src/main.rs b/services/trading_service/src/main.rs
index 44850482b..a20c21f32 100644
--- a/services/trading_service/src/main.rs
+++ b/services/trading_service/src/main.rs
@@ -263,7 +263,7 @@ async fn main() -> Result<()> {
                     ml::ModelType::DQN,
                 ));
                 if let Err(e) = coordinator
-                    .register_loaded_model("DQN".to_string(), bridge, 0.25)
+                    .register_loaded_model("DQN".to_string(), bridge, 0.10)
                     .await
                 {
                     warn!("Failed to register DQN adapter: {}", e);
@@ -289,7 +289,7 @@ async fn main() -> Result<()> {
                     ml::ModelType::PPO,
                 ));
                 if let Err(e) = coordinator
-                    .register_loaded_model("PPO".to_string(), bridge, 0.25)
+                    .register_loaded_model("PPO".to_string(), bridge, 0.10)
                     .await
                 {
                     warn!("Failed to register PPO adapter: {}", e);
@@ -324,7 +324,7 @@ async fn main() -> Result<()> {
                     ml::ModelType::TFT,
                 ));
                 if let Err(e) = coordinator
-                    .register_loaded_model("TFT".to_string(), bridge, 0.20)
+                    .register_loaded_model("TFT".to_string(), bridge, 0.10)
                     .await
                 {
                     warn!("Failed to register TFT adapter: {}", e);
@@ -355,7 +355,7 @@ async fn main() -> Result<()> {
                     ml::ModelType::MAMBA,
                 ));
                 if let Err(e) = coordinator
-                    .register_loaded_model("MAMBA2".to_string(), bridge, 0.15)
+                    .register_loaded_model("MAMBA2".to_string(), bridge, 0.10)
                     .await
                 {
                     warn!("Failed to register MAMBA2 adapter: {}", e);
@@ -385,7 +385,7 @@ async fn main() -> Result<()> {
                     ml::ModelType::LNN,
                 ));
                 if let Err(e) = coordinator
-                    .register_loaded_model("Liquid-CfC".to_string(), bridge, 0.15)
+                    .register_loaded_model("Liquid-CfC".to_string(), bridge, 0.10)
                     .await
                 {
                     warn!("Failed to register Liquid-CfC adapter: {}", e);
@@ -396,10 +396,131 @@ async fn main() -> Result<()> {
             Err(e) => warn!("Failed to create Liquid-CfC inference adapter: {}", e),
         }
 
+        // TGGN adapter (51-dim input, 2-layer candle projection)
+        match ml::ensemble::adapters::TggnInferenceAdapter::new(51, 64) {
+            Ok(adapter) => {
+                let bridge = Arc::new(InferenceAdapterBridge::new(
+                    Box::new(adapter),
+                    "TGGN".to_string(),
+                    ml::ModelType::TGGN,
+                ));
+                if let Err(e) = coordinator
+                    .register_loaded_model("TGGN".to_string(), bridge, 0.10)
+                    .await
+                {
+                    warn!("Failed to register TGGN adapter: {}", e);
+                } else {
+                    info!("Registered TGGN inference adapter (51-dim, candle projection)");
+                }
+            }
+            Err(e) => warn!("Failed to create TGGN inference adapter: {}", e),
+        }
+
+        // TLOB adapter (51-dim features, 3-layer MLP, seq_len=10)
+        match ml::ensemble::adapters::TlobInferenceAdapter::new(51, 64, 10) {
+            Ok(adapter) => {
+                let bridge = Arc::new(InferenceAdapterBridge::new(
+                    Box::new(adapter),
+                    "TLOB".to_string(),
+                    ml::ModelType::TLOB,
+                ));
+                if let Err(e) = coordinator
+                    .register_loaded_model("TLOB".to_string(), bridge, 0.10)
+                    .await
+                {
+                    warn!("Failed to register TLOB adapter: {}", e);
+                } else {
+                    info!("Registered TLOB inference adapter (51-dim, seq=10, candle MLP)");
+                }
+            }
+            Err(e) => warn!("Failed to create TLOB inference adapter: {}", e),
+        }
+
+        // KAN adapter (51-dim input, B-spline activations)
+        match ml::ensemble::adapters::KanInferenceAdapter::new(ml::kan::KANConfig {
+            layer_widths: vec![51, 32, 16, 1],
+            ..Default::default()
+        }) {
+            Ok(adapter) => {
+                let bridge = Arc::new(InferenceAdapterBridge::new(
+                    Box::new(adapter),
+                    "KAN".to_string(),
+                    ml::ModelType::KAN,
+                ));
+                if let Err(e) = coordinator
+                    .register_loaded_model("KAN".to_string(), bridge, 0.10)
+                    .await
+                {
+                    warn!("Failed to register KAN adapter: {}", e);
+                } else {
+                    info!("Registered KAN inference adapter (51-dim, B-spline, candle)");
+                }
+            }
+            Err(e) => warn!("Failed to create KAN inference adapter: {}", e),
+        }
+
+        // xLSTM adapter (51-dim input, sLSTM+mLSTM, seq_len=10)
+        match ml::ensemble::adapters::XlstmInferenceAdapter::new(
+            ml::xlstm::XLSTMConfig {
+                input_dim: 51,
+                hidden_dim: 64,
+                num_blocks: 2,
+                num_heads: 2,
+                ..Default::default()
+            },
+            10, // sequence_length for buffer
+        ) {
+            Ok(adapter) => {
+                let bridge = Arc::new(InferenceAdapterBridge::new(
+                    Box::new(adapter),
+                    "xLSTM".to_string(),
+                    ml::ModelType::XLSTM,
+                ));
+                if let Err(e) = coordinator
+                    .register_loaded_model("xLSTM".to_string(), bridge, 0.10)
+                    .await
+                {
+                    warn!("Failed to register xLSTM adapter: {}", e);
+                } else {
+                    info!("Registered xLSTM inference adapter (51-dim, seq=10, candle)");
+                }
+            }
+            Err(e) => warn!("Failed to create xLSTM inference adapter: {}", e),
+        }
+
+        // Diffusion adapter (51-dim features, DDPM denoiser, t=1 inference)
+        match ml::ensemble::adapters::DiffusionInferenceAdapter::new(ml::diffusion::DiffusionConfig {
+            seq_len: 1,
+            feature_dim: 51,
+            hidden_dim: 64,
+            num_layers: 2,
+            time_embed_dim: 32,
+            num_timesteps: 100,
+            sampling_steps: 5,
+            ..Default::default()
+        }) {
+            Ok(adapter) => {
+                let bridge = Arc::new(InferenceAdapterBridge::new(
+                    Box::new(adapter),
+                    "Diffusion".to_string(),
+                    ml::ModelType::Diffusion,
+                ));
+                if let Err(e) = coordinator
+                    .register_loaded_model("Diffusion".to_string(), bridge, 0.10)
+                    .await
+                {
+                    warn!("Failed to register Diffusion adapter: {}", e);
+                } else {
+                    info!("Registered Diffusion inference adapter (51-dim, DDPM, candle)");
+                }
+            }
+            Err(e) => warn!("Failed to create Diffusion inference adapter: {}", e),
+        }
+
         let model_count = coordinator.model_count().await;
         info!(
             "Ensemble coordinator initialized with {} real inference adapters \
-             (DQN=0.25, PPO=0.25, TFT=0.20, MAMBA2=0.15, Liquid-CfC=0.15)",
+             (all 10 models at 0.10 weight each)",
             model_count
         );