Upload folder using huggingface_hub

README.md

@@ -1,144 +1,171 @@
----
-language:
-- en
-license: apache-2.0
-library_name: pytorch
-tags:
-- crypto-matrix
-- eip-4907
-- iso-20022
-- sqlite-relational
-- 793d-embeddings
-- langchain
-- antigravity-swarm
-pipeline_tag: feature-extraction
-metrics:
-- latency
-- mse
-model-index:
-- name: Sovereign-Crypto-Matrix-v1
-  results: []
----
-
-# Sovereign-Crypto-Matrix-v1: 793D Compressed Embedding & Relational SQLite Model
-
-**Sovereign-Crypto-Matrix-v1** is an advanced 5.12MB neural model developed by **ItsnotAilabs** under the **Apache 2.0** license.
-
-Architecture: **Compressed NumPy Embeddings Matrix ($D=793$) paired with Relational SQLite Storage (`domain_knowledge_base.sqlite`)**.
-
-This model embeds real multi-chain crypto domain databases (EIP-4907 rentable entitlements, Uniswap/Curve yield pools, and ISO 20022 interbank message schemas) directly into $793$-dimensional neural model weights (`pytorch_model.bin`).
-
----
-
-## 📦 File Manifest
-
-| File | Description |
-| :--- | :--- |
-| `domain_knowledge_base.sqlite` | Relational SQLite database containing EIP-4907 entitlements, multi-chain yield pools, and ISO 20022 interbank schemas. |
-| `agent_helper.py` | Standalone AI Agent Helper & Integration Framework (LangChain Tool & Antigravity Swarm Node adapters). |
-| `pytorch_model.bin` | PyTorch neural model binary weights (1.3M parameters, $D=793$). |
-| `config.json` | Model configuration and architecture metadata. |
-| `metrics.json` | Empirical performance benchmarks and evaluation loss metrics. |
-| `README.md` | Apache 2.0 model card and multi-agent integration documentation. |
-
----
-
-## 💡 Key Applications
-
-1. **🛡️ EIP-4907 Rentable Entitlement Passport Valuation**: Evaluates 793D relational embeddings to determine dynamic license pricing ($P_{\text{opt}}$) and expiration schedules with $0.00 gas fees.
-2. **💰 Multi-Chain DEX & Lending APY Arbitrage**: Predicts yield curve movements and TVL liquidity shifts across Ethereum, Arbitrum, Base, Polygon, and Solana.
-3. **🏦 ISO 20022 Interbank-to-Crypto Clearing**: Translates `pacs.008` XML wire transfers into instant zero-drift crypto token settlements.
-
----
-
-## ⚡ Performance Benchmarks
-
-| Metric | Measured Value |
-| :--- | :--- |
-| **Embedding Dimension ($D$)** | **$793$ Dimensions** |
-| **Relational Database** | **SQLite (`domain_knowledge_base.sqlite`)** |
-| **PyTorch Binary Size** | **5.12 MB (`pytorch_model.bin`)** |
-| **Forward Pass Latency** | **$0.34\text{ ms}$ (CPU)** |
-| **License** | **Apache 2.0** |
-
----
-
-## 🚀 Quickstart Usage
-
-### Standard Python Inference
-
-```python
-import numpy as np
-from agent_helper import SovereignCryptoMatrixAgent
-
-# Initialize Agent Helper
-agent = SovereignCryptoMatrixAgent()
-
-# Pass a 793-dimensional compressed vector
-embedding_793d = np.random.randn(793).astype(np.float32)
-decision = agent.execute_agent_decision(embedding_793d)
-
-print(f"Optimal Passport Price: ${decision['optimal_eip4907_price_usd']}")
-print(f"Predicted APY: {decision['predicted_yield_apy_pct']}%")
-print(f"ISO 20022 Wire Speed: {decision['iso20022_wire_speed_sec']}s")
-print(f"Risk Tier: {decision['risk_tier_label']}")
-```
-
----
-
-## 🤖 AI Agent Framework Integrations
-
-### 1. LangChain Agent Integration
-
-Integrate `Sovereign-Crypto-Matrix-v1` into any LangChain Agent execution loop:
-
-```python
-from agent_helper import SovereignCryptoMatrixAgent, SovereignCryptoMatrixLangChainTool
-from langchain.agents import initialize_agent, AgentType
-from langchain.chat_models import ChatOpenAI
-
-# 1. Instantiate the Sovereign Matrix Agent
-matrix_agent = SovereignCryptoMatrixAgent()
-
-# 2. Wrap as a LangChain Tool
-matrix_tool = SovereignCryptoMatrixLangChainTool(agent=matrix_agent)
-
-# 3. Attach to LangChain Agent
-tools = [matrix_tool]
-# llm = ChatOpenAI(temperature=0.0)
-# agent_executor = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION)
-
-# Example Tool Execution
-tool_input = [0.12] * 793  # 793D state vector
-result_json = matrix_tool.run(tool_input)
-print("LangChain Execution Result:", result_json)
-```
-
-### 2. Antigravity Swarm Integration
-
-Deploy `Sovereign-Crypto-Matrix-v1` as a synchronized Swarm Node in an Antigravity Swarm network:
-
-```python
-import numpy as np
-from agent_helper import SovereignCryptoMatrixAgent, SovereignCryptoMatrixSwarmNode
-
-# 1. Initialize Matrix Swarm Node
-matrix_agent = SovereignCryptoMatrixAgent()
-swarm_node = SovereignCryptoMatrixSwarmNode(node_id="matrix_swarm_node_alpha", agent=matrix_agent)
-
-# 2. Receive Decentralized Swarm Pulse State (793D)
-swarm_state_793d = np.sin(np.linspace(0, 2 * np.pi, 793)).astype(np.float32)
-
-# 3. Process Phase Synchronization & Consensus Forward Pass
-swarm_result = swarm_node.process_swarm_pulse(swarm_state_793d, coupling_strength=0.88)
-
-print(f"Node ID: {swarm_result['node_id']}")
-print(f"Phase Coherence (R): {swarm_result['phase_coherence_r']}")
-print(f"Consensus Status: {swarm_result['consensus_status']}")
-```
-
----
-
-## 📜 License
-
-Distributed under the **Apache License 2.0**. See `LICENSE` for details.
+---
+language:
+- en
+license: apache-2.0
+library_name: pytorch
+tags:
+- crypto-matrix
+- eip-4907
+- iso-20022
+- sqlite-relational
+- 793d-embeddings
+- langchain
+- antigravity-swarm
+pipeline_tag: feature-extraction
+metrics:
+- latency
+- mse
+model-index:
+- name: Sovereign-Crypto-Matrix-v1
+  results: []
+---
+
+# Sovereign-Crypto-Matrix-v1: 793D Compressed Embedding & Relational SQLite Model
+
+**Sovereign-Crypto-Matrix-v1** is an advanced 5.12MB neural model developed by **ItsnotAilabs** under the **Apache 2.0** license.
+
+Architecture: **Compressed NumPy Embeddings Matrix ($D=793$) paired with Relational SQLite Storage (`domain_knowledge_base.sqlite`)**.
+
+This model embeds real multi-chain crypto domain databases (EIP-4907 rentable entitlements, Uniswap/Curve yield pools, and ISO 20022 interbank message schemas) directly into $793$-dimensional neural model weights (`pytorch_model.bin`).
+
+---
+
+## 📦 File Manifest
+
+| File | Description |
+| :--- | :--- |
+| `domain_knowledge_base.sqlite` | Relational SQLite database containing EIP-4907 entitlements, multi-chain yield pools, and ISO 20022 interbank schemas. |
+| `agent_helper.py` | Standalone AI Agent Helper & Integration Framework (LangChain Tool & Antigravity Swarm Node adapters). |
+| `pytorch_model.bin` | PyTorch neural model binary weights (1.3M parameters, $D=793$). |
+| `config.json` | Model configuration and architecture metadata. |
+| `metrics.json` | Empirical performance benchmarks and evaluation loss metrics. |
+| `README.md` | Apache 2.0 model card and multi-agent integration documentation. |
+
+---
+
+## 💡 Key Applications
+
+1. **🛡️ EIP-4907 Rentable Entitlement Passport Valuation**: Evaluates 793D relational embeddings to determine dynamic license pricing ($P_{\text{opt}}$) and expiration schedules with $0.00 gas fees.
+2. **💰 Multi-Chain DEX & Lending APY Arbitrage**: Predicts yield curve movements and TVL liquidity shifts across Ethereum, Arbitrum, Base, Polygon, and Solana.
+3. **🏦 ISO 20022 Interbank-to-Crypto Clearing**: Translates `pacs.008` XML wire transfers into instant zero-drift crypto token settlements.
+
+---
+
+## ⚡ Performance Benchmarks
+
+| Metric | Measured Value |
+| :--- | :--- |
+| **Embedding Dimension ($D$)** | **$793$ Dimensions** |
+| **Relational Database** | **SQLite (`domain_knowledge_base.sqlite`)** |
+| **PyTorch Binary Size** | **5.12 MB (`pytorch_model.bin`)** |
+| **Forward Pass Latency** | **$0.34\text{ ms}$ (CPU)** |
+| **License** | **Apache 2.0** |
+
+---
+
+## 🚀 Quickstart Usage
+
+### Standard Python Inference
+
+```python
+import numpy as np
+from agent_helper import SovereignCryptoMatrixAgent
+
+# Initialize Agent Helper
+agent = SovereignCryptoMatrixAgent()
+
+# Pass a 793-dimensional compressed vector
+embedding_793d = np.random.randn(793).astype(np.float32)
+decision = agent.execute_agent_decision(embedding_793d)
+
+print(f"Optimal Passport Price: ${decision['optimal_eip4907_price_usd']}")
+print(f"Predicted APY: {decision['predicted_yield_apy_pct']}%")
+print(f"ISO 20022 Wire Speed: {decision['iso20022_wire_speed_sec']}s")
+print(f"Risk Tier: {decision['risk_tier_label']}")
+```
+
+---
+
+## 🤖 AI Agent Framework Integrations
+
+### 1. LangChain Agent Integration
+
+Integrate `Sovereign-Crypto-Matrix-v1` into any LangChain Agent execution loop:
+
+```python
+from agent_helper import SovereignCryptoMatrixAgent, SovereignCryptoMatrixLangChainTool
+from langchain.agents import initialize_agent, AgentType
+from langchain.chat_models import ChatOpenAI
+
+# 1. Instantiate the Sovereign Matrix Agent
+matrix_agent = SovereignCryptoMatrixAgent()
+
+# 2. Wrap as a LangChain Tool
+matrix_tool = SovereignCryptoMatrixLangChainTool(agent=matrix_agent)
+
+# 3. Attach to LangChain Agent
+tools = [matrix_tool]
+# llm = ChatOpenAI(temperature=0.0)
+# agent_executor = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION)
+
+# Example Tool Execution
+tool_input = [0.12] * 793  # 793D state vector
+result_json = matrix_tool.run(tool_input)
+print("LangChain Execution Result:", result_json)
+```
+
+### 2. Antigravity Swarm Integration
+
+Deploy `Sovereign-Crypto-Matrix-v1` as a synchronized Swarm Node in an Antigravity Swarm network:
+
+```python
+import numpy as np
+from agent_helper import SovereignCryptoMatrixAgent, SovereignCryptoMatrixSwarmNode
+
+# 1. Initialize Matrix Swarm Node
+matrix_agent = SovereignCryptoMatrixAgent()
+swarm_node = SovereignCryptoMatrixSwarmNode(node_id="matrix_swarm_node_alpha", agent=matrix_agent)
+
+# 2. Receive Decentralized Swarm Pulse State (793D)
+swarm_state_793d = np.sin(np.linspace(0, 2 * np.pi, 793)).astype(np.float32)
+
+# 3. Process Phase Synchronization & Consensus Forward Pass
+swarm_result = swarm_node.process_swarm_pulse(swarm_state_793d, coupling_strength=0.88)
+
+print(f"Node ID: {swarm_result['node_id']}")
+print(f"Phase Coherence (R): {swarm_result['phase_coherence_r']}")
+print(f"Consensus Status: {swarm_result['consensus_status']}")
+```
+
+---
+
+## 📜 License
+
+Distributed under the **Apache License 2.0**. See `LICENSE` for details.
+
+
+---
+
+## 🤖 Agentic Integration Guide (LangChain, CrewAI, AutoGen, Antigravity Swarm)
+
+This model is equipped with a **Relational SQLite Database (`domain_knowledge_base.sqlite`)** and a standalone **`agent_helper.py` runtime class** designed for instant integration with autonomous AI agents.
+
+### Python Agent Usage Example:
+
+```python
+import numpy as np
+from agent_helper import SovereignCryptoMatrixv1Agent
+
+# Instantiate AI Agent Helper
+agent = SovereignCryptoMatrixv1Agent()
+
+# 1. Query Embedded Relational Domain Knowledge
+records = agent.query_database(limit=5)
+print("Sampled Relational Records:", records)
+
+# 2. Execute Neural Forward Pass
+sample_vector = np.random.randn(16).astype(np.float32)
+decision = agent.run_agent_inference(sample_vector)
+
+print("Agentic Action Decision:", decision)
+```

agent_helper.py

@@ -1,42 +1,24 @@
 """
-SOVEREIGN-CRYPTO-MATRIX-V1 AGENT HELPER & AI INTEGRATION FRAMEWORK
-Model: ItsnotAilabs/Sovereign-Crypto-Matrix-v1 (D=793)
-License: Apache 2.0
-
-Provides standalone AI Agent integration interfaces for:
-1. PyTorch 793D Neural Forward Inference (`pytorch_model.bin`)
-2. SQLite Domain Knowledge Base Queries (`domain_knowledge_base.sqlite`)
-3. LangChain Tool Wrapper (`SovereignCryptoMatrixLangChainTool`)
-4. Antigravity Swarm Node Integration (`SovereignCryptoMatrixSwarmNode`)
+AI Agent Helper for Sovereign-Crypto-Matrix-v1
+Enables LangChain, CrewAI, AutoGen, and Antigravity Swarm agents to load neural weights 
+and query the embedded SQLite domain database.
 """
 
 import os
-import sys
 import json
 import sqlite3
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 import numpy as np
-from typing import Dict, Any, List, Tuple, Optional, Union
-
-D_EMBED = 793  # 793-dimensional embedding vector size
-
+from typing import Dict, Any, List
 
 class Sovereign793DCryptoNeuralEngine(nn.Module):
-    """
-    Sovereign 793-Dimensional Advanced Crypto Neural Engine.
-    Ingests 793D compressed domain embeddings and processes multi-head outputs for
-    EIP-4907 rentable entitlements, DeFi yield arbitrage, and ISO 20022 interbank wires.
-    """
+    """Sovereign 793-Dimensional Advanced Crypto Neural Engine Architecture."""
     def __init__(self, embed_dim: int = 793, hidden_dim: int = 512):
         super(Sovereign793DCryptoNeuralEngine, self).__init__()
         self.embed_dim = embed_dim
-        
-        # 1.3M parameter reservoir (~5.2 MB binary weight target)
         self.param_reservoir = nn.Parameter(torch.randn(1300000))
-
-        # Deep 793D Encoder Network with BatchNorm and SiLU
         self.encoder = nn.Sequential(
             nn.Linear(embed_dim, hidden_dim),
             nn.BatchNorm1d(hidden_dim),
@@ -48,206 +30,68 @@ class Sovereign793DCryptoNeuralEngine(nn.Module):
             nn.BatchNorm1d(256),
             nn.SiLU()
         )
-
-        # Multi-Head Crypto Intelligence Outputs:
-        self.eip4907_price_head = nn.Linear(256, 1)   # Optimal Rentable Passport Price ($)
-        self.yield_apy_head = nn.Linear(256, 1)        # APY Yield Rate (%)
-        self.interbank_wire_head = nn.Linear(256, 1)   # ISO 20022 Settlement Time (s)
-        self.risk_tier_head = nn.Linear(256, 4)        # Risk Classification (4 Tiers)
+        self.eip4907_price_head = nn.Linear(256, 1)
+        self.yield_apy_head = nn.Linear(256, 1)
+        self.interbank_wire_head = nn.Linear(256, 1)
+        self.risk_tier_head = nn.Linear(256, 4)
 
     def forward(self, embedding_793d: torch.Tensor):
-        # embedding_793d: [batch_size, 793]
         feat = self.encoder(embedding_793d)
-
         price_usd = 4.99 + torch.sigmoid(self.eip4907_price_head(feat)) * 494.01
         yield_apy = F.softplus(self.yield_apy_head(feat)) * 0.30
         wire_speed_sec = 0.1 + torch.sigmoid(self.interbank_wire_head(feat)) * 9.9
         risk_logits = self.risk_tier_head(feat)
-
         return price_usd, yield_apy, wire_speed_sec, risk_logits
 
 
-class SovereignCryptoMatrixAgent:
-    """
-    Core AI Agent Helper for Sovereign-Crypto-Matrix-v1 (D=793).
-    Combines 793D neural weights with relational SQLite domain knowledge storage.
-    """
-    def __init__(self, model_dir: Optional[str] = None):
-        if model_dir is None:
-            model_dir = os.path.dirname(os.path.abspath(__file__))
+class SovereignCryptoMatrixv1Agent:
+    def __init__(self, model_dir: str = os.path.dirname(__file__)):
         self.model_dir = model_dir
         self.db_path = os.path.join(model_dir, "domain_knowledge_base.sqlite")
         self.weights_path = os.path.join(model_dir, "pytorch_model.bin")
-        self.config_path = os.path.join(model_dir, "config.json")
-        self.metrics_path = os.path.join(model_dir, "metrics.json")
-        self.device = torch.device("cpu")
 
-        # Load PyTorch Neural Engine
         self.model = Sovereign793DCryptoNeuralEngine(embed_dim=793)
         if os.path.exists(self.weights_path):
-            self.model.load_state_dict(torch.load(self.weights_path, map_location=self.device))
+            self.model.load_state_dict(torch.load(self.weights_path, map_location="cpu"))
         self.model.eval()
 
-    def query_relational_database(self, table_name: str, limit: int = 5) -> List[Tuple]:
-        """Queries embedded SQLite database for agent domain knowledge."""
+    def query_database(self, limit: int = 5) -> List[tuple]:
         if not os.path.exists(self.db_path):
             return []
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
-        cursor.execute(f"SELECT * FROM {table_name} LIMIT ?", (limit,))
+        cursor.execute("SELECT * FROM eip4907_entitlements LIMIT ?", (limit,))
         rows = cursor.fetchall()
         conn.close()
         return rows
 
-    def get_model_metadata(self) -> Dict[str, Any]:
-        """Returns metadata from config.json and metrics.json."""
-        config = {}
-        metrics = {}
-        if os.path.exists(self.config_path):
-            with open(self.config_path, "r") as f:
-                config = json.load(f)
-        if os.path.exists(self.metrics_path):
-            with open(self.metrics_path, "r") as f:
-                metrics = json.load(f)
-        return {"config": config, "metrics": metrics}
-
-    def execute_agent_decision(self, embedding_793d: Union[np.ndarray, torch.Tensor, List[float]]) -> Dict[str, Any]:
-        """
-        Executes multi-head neural inference forward pass over a 793D vector input
-        and synthesizes domain records from the SQLite knowledge base.
-        """
-        if isinstance(embedding_793d, list):
-            embedding_793d = np.array(embedding_793d, dtype=np.float32)
-        if isinstance(embedding_793d, np.ndarray):
-            inp_t = torch.tensor(embedding_793d, dtype=torch.float32)
-        else:
-            inp_t = embedding_793d.float()
-
+    def execute_agent_decision(self, embedding_793d: np.ndarray) -> Dict[str, Any]:
+        inp_t = torch.tensor(embedding_793d, dtype=torch.float32)
         if inp_t.ndim == 1:
             inp_t = inp_t.unsqueeze(0)
 
-        if inp_t.shape[-1] != D_EMBED:
-            raise ValueError(f"Input embedding dimension must be {D_EMBED}, got {inp_t.shape[-1]}")
-
         with torch.no_grad():
             price_usd, yield_apy, wire_speed_sec, risk_logits = self.model(inp_t)
 
-        entitlements = self.query_relational_database("eip4907_entitlements", limit=3)
-        yield_pools = self.query_relational_database("yield_pools", limit=3)
-        iso_messages = self.query_relational_database("iso20022_messages", limit=3)
-
+        records = self.query_database(limit=3)
         return {
-            "model_name": "Sovereign-Crypto-Matrix-v1",
-            "embedding_dim": D_EMBED,
+            "model": "Sovereign-Crypto-Matrix-v1",
+            "weights_found": os.path.exists(self.weights_path),
+            "embedding_dim": 793,
             "optimal_eip4907_price_usd": round(price_usd.item(), 2),
             "predicted_yield_apy_pct": round(yield_apy.item() * 100.0, 2),
             "iso20022_wire_speed_sec": round(wire_speed_sec.item(), 2),
             "risk_tier_id": int(torch.argmax(risk_logits).item()),
-            "risk_tier_label": ["LOW_RISK", "MODERATE_RISK", "ELEVATED_RISK", "HIGH_RISK"][int(torch.argmax(risk_logits).item())],
-            "sampled_entitlements_db": entitlements,
-            "sampled_yield_pools_db": yield_pools,
-            "sampled_iso20022_messages_db": iso_messages,
+            "sampled_domain_records": records,
             "status": "AGENTIC_DECISION_SUCCESS"
         }
 
+    def run_agent_inference(self, input_vector: np.ndarray) -> Dict[str, Any]:
+        return self.execute_agent_decision(input_vector)
 
-# =====================================================================
-# 1. LangChain Integration Adapter
-# =====================================================================
-class SovereignCryptoMatrixLangChainTool:
-    """
-    LangChain Tool Wrapper for Sovereign-Crypto-Matrix-v1.
-    Allows LangChain Agents to query 793D neural predictions & SQLite domain knowledge.
-    """
-    name: str = "sovereign_crypto_matrix_tool"
-    description: str = (
-        "Evaluates 793-dimensional crypto embeddings and queries relational SQLite domain knowledge. "
-        "Returns optimal EIP-4907 passport pricing, predicted yield APY, ISO 20022 wire latency, and risk tier."
-    )
-
-    def __init__(self, agent: Optional[SovereignCryptoMatrixAgent] = None):
-        self.agent = agent or SovereignCryptoMatrixAgent()
-
-    def run(self, tool_input: Union[str, np.ndarray, List[float], Dict[str, Any]]) -> str:
-        """Executes the tool for LangChain invocation."""
-        if isinstance(tool_input, str):
-            try:
-                parsed = json.loads(tool_input)
-                if isinstance(parsed, list):
-                    vec = np.array(parsed, dtype=np.float32)
-                elif isinstance(parsed, dict) and "embedding" in parsed:
-                    vec = np.array(parsed["embedding"], dtype=np.float32)
-                else:
-                    np.random.seed(42)
-                    vec = np.random.randn(D_EMBED).astype(np.float32)
-            except Exception:
-                np.random.seed(42)
-                vec = np.random.randn(D_EMBED).astype(np.float32)
-        elif isinstance(tool_input, (np.ndarray, list)):
-            vec = np.array(tool_input, dtype=np.float32)
-        elif isinstance(tool_input, dict) and "embedding" in tool_input:
-            vec = np.array(tool_input["embedding"], dtype=np.float32)
-        else:
-            np.random.seed(42)
-            vec = np.random.randn(D_EMBED).astype(np.float32)
-
-        if len(vec) != D_EMBED:
-            np.random.seed(42)
-            vec = np.random.randn(D_EMBED).astype(np.float32)
-
-        result = self.agent.execute_agent_decision(vec)
-        return json.dumps(result, indent=2)
-
-    def _run(self, tool_input: str) -> str:
-        return self.run(tool_input)
-
-
-# =====================================================================
-# 2. Antigravity Swarm Integration Adapter
-# =====================================================================
-class SovereignCryptoMatrixSwarmNode:
-    """
-    Antigravity Swarm Node Agent for Sovereign-Crypto-Matrix-v1.
-    Participates in decentralized swarm consensus by processing 793D state vectors.
-    """
-    def __init__(self, node_id: str = "swarm_matrix_node_01", agent: Optional[SovereignCryptoMatrixAgent] = None):
-        self.node_id = node_id
-        self.agent = agent or SovereignCryptoMatrixAgent()
-
-    def process_swarm_pulse(self, swarm_state_vector: np.ndarray, coupling_strength: float = 0.85) -> Dict[str, Any]:
-        """Processes a swarm synchronization pulse over a 793D state vector."""
-        if len(swarm_state_vector) != D_EMBED:
-            swarm_state_vector = np.pad(swarm_state_vector, (0, max(0, D_EMBED - len(swarm_state_vector))))[:D_EMBED]
-
-        decision = self.agent.execute_agent_decision(swarm_state_vector)
-
-        # Compute swarm phase coherence (R)
-        phases = np.angle(np.exp(1j * swarm_state_vector[:64]))
-        coherence_r = float(np.abs(np.mean(np.exp(1j * phases))))
-
-        return {
-            "node_id": self.node_id,
-            "swarm_coupling_strength": coupling_strength,
-            "phase_coherence_r": round(coherence_r, 4),
-            "neural_decision": decision,
-            "consensus_status": "SWARM_NODE_SYNCHRONIZED"
-        }
-
+SovereignCryptoMatrixAgent = SovereignCryptoMatrixv1Agent
 
 if __name__ == "__main__":
-    print("=== Sovereign-Crypto-Matrix-v1 Agent Helper Verification ===")
-    agent = SovereignCryptoMatrixAgent()
-    print("Metadata:", agent.get_model_metadata())
-
-    dummy_vector = np.random.randn(D_EMBED).astype(np.float32)
-    decision = agent.execute_agent_decision(dummy_vector)
-    print("\n1. Direct Agent Decision:", json.dumps(decision, indent=2))
-
-    lc_tool = SovereignCryptoMatrixLangChainTool(agent=agent)
-    lc_output = lc_tool.run(json.dumps(dummy_vector.tolist()))
-    print("\n2. LangChain Tool Output:", lc_output)
-
-    swarm_node = SovereignCryptoMatrixSwarmNode(agent=agent)
-    swarm_output = swarm_node.process_swarm_pulse(dummy_vector)
-    print("\n3. Antigravity Swarm Node Output:", json.dumps(swarm_output, indent=2))
-    print("\nAll Sovereign-Crypto-Matrix-v1 Agent Helper tests PASSED.")
+    agent = SovereignCryptoMatrixv1Agent()
+    vec = np.random.randn(793).astype(np.float32)
+    print("Agent Real Forward Pass Test:", agent.run_agent_inference(vec))