🚀 OS Launch: Clean documentation and refined licensing

This OS launch commit includes:

✅ **Cleaned Documentation**
- Removed inflated claims and marketing language
- Added honest research status and limitations
- Created professional model card and validation reports
- Streamlined licensing to AGPLv3 + commercial contact

✅ **Refined Codebase**
- Complete experimental bit-native transformer implementation
- 57 Python files with comprehensive research framework
- Safety telemetry and monitoring systems
- Distributed training and development tools

✅ **Professional Standards**
- Empirical validation of all claims
- Clear experimental vs production distinctions
- Rigorous research methodology requirements
- Community contribution framework

Ready for serious research evaluation and academic investigation.

launch_dual_dashboard.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+BitTransformerLM Dual Dashboard Launcher
+========================================
+
+Launch both Flask and Gradio dashboards simultaneously for maximum flexibility.
+- Flask Dashboard: http://localhost:5000 (Docker/production compatible)
+- Gradio Dashboard: http://localhost:7860 (HuggingFace Spaces compatible)
+- MCP Server: http://localhost:8000 (if enabled)
+"""
+
+import os
+import sys
+import time
+import threading
+import subprocess
+from pathlib import Path
+
+# Add current directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+def launch_flask_dashboard():
+    """Launch the Flask dashboard in a separate thread."""
+    print("🌐 Starting Flask Dashboard...")
+    try:
+        os.environ["FLASK_ENV"] = "development"
+        
+        # Import and run Flask app
+        from bit_transformer.dashboard_app import app
+        app.run(host="127.0.0.1", port=5000, debug=False, use_reloader=False)
+    except Exception as e:
+        print(f"❌ Flask dashboard failed: {e}")
+
+def launch_gradio_dashboard():
+    """Launch the Gradio dashboard in a separate thread."""
+    print("🎨 Starting Gradio Dashboard...")
+    try:
+        from gradio_dashboard import run_gradio_server
+        run_gradio_server(host="127.0.0.1", port=7860, share=False)
+    except Exception as e:
+        print(f"❌ Gradio dashboard failed: {e}")
+
+def launch_mcp_server():
+    """Launch the MCP server if requested."""
+    print("🔗 Starting MCP Server...")
+    try:
+        from mcp_server import app as mcp_app
+        mcp_app.run(host="127.0.0.1", port=8000, debug=False, use_reloader=False)
+    except Exception as e:
+        print(f"❌ MCP server failed: {e}")
+
+def main():
+    """Main launcher function."""
+    print("🚀 BitTransformerLM Dual Dashboard Launcher")
+    print("=" * 50)
+    
+    # Check requirements
+    try:
+        import flask
+        import gradio
+        print(f"✅ Flask {flask.__version__} and Gradio {gradio.__version__} are available")
+    except ImportError as e:
+        print(f"❌ Missing dependencies: {e}")
+        print("Please run: pip install -r requirements-gradio.txt")
+        return
+    
+    # Configuration
+    enable_flask = os.getenv("ENABLE_FLASK", "true").lower() == "true"
+    enable_gradio = os.getenv("ENABLE_GRADIO", "true").lower() == "true"
+    enable_mcp = os.getenv("ENABLE_MCP", "false").lower() == "true"
+    
+    print(f"🔧 Configuration:")
+    print(f"   Flask Dashboard: {'Enabled' if enable_flask else 'Disabled'}")
+    print(f"   Gradio Dashboard: {'Enabled' if enable_gradio else 'Disabled'}")
+    print(f"   MCP Server: {'Enabled' if enable_mcp else 'Disabled'}")
+    print()
+    
+    # Launch threads
+    threads = []
+    
+    if enable_flask:
+        flask_thread = threading.Thread(target=launch_flask_dashboard, daemon=True)
+        flask_thread.start()
+        threads.append(("Flask", flask_thread))
+        time.sleep(2)  # Stagger startup
+    
+    if enable_mcp:
+        # Set MCP server address for other components
+        os.environ["MCP_SERVER_ADDR"] = "http://localhost:8000"
+        mcp_thread = threading.Thread(target=launch_mcp_server, daemon=True)
+        mcp_thread.start()
+        threads.append(("MCP", mcp_thread))
+        time.sleep(2)  # Stagger startup
+    
+    if enable_gradio:
+        gradio_thread = threading.Thread(target=launch_gradio_dashboard, daemon=True)
+        gradio_thread.start()
+        threads.append(("Gradio", gradio_thread))
+    
+    # Wait for startup
+    time.sleep(3)
+    
+    # Print access URLs
+    print("🌍 Access URLs:")
+    if enable_flask:
+        print("   Flask Dashboard:  http://localhost:5000")
+    if enable_gradio:
+        print("   Gradio Dashboard: http://localhost:7860")
+    if enable_mcp:
+        print("   MCP Server:       http://localhost:8000")
+    print()
+    
+    print("💡 Usage Tips:")
+    print("   • Flask dashboard: Full Docker/production compatibility")  
+    print("   • Gradio dashboard: HuggingFace Spaces ready interface")
+    print("   • MCP server: Programmatic API access")
+    print("   • Both dashboards share the same model state")
+    print("   • Press Ctrl+C to stop all services")
+    print()
+    
+    try:
+        # Keep main thread alive
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\n🛑 Shutting down all services...")
+        # Threads will be cleaned up automatically as they are daemon threads
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="BitTransformerLM Dual Dashboard")
+    parser.add_argument("--flask-only", action="store_true", help="Launch only Flask dashboard")
+    parser.add_argument("--gradio-only", action="store_true", help="Launch only Gradio dashboard")
+    parser.add_argument("--enable-mcp", action="store_true", help="Enable MCP server")
+    
+    args = parser.parse_args()
+    
+    # Override environment based on args
+    if args.flask_only:
+        os.environ["ENABLE_FLASK"] = "true"
+        os.environ["ENABLE_GRADIO"] = "false"
+    elif args.gradio_only:
+        os.environ["ENABLE_FLASK"] = "false"
+        os.environ["ENABLE_GRADIO"] = "true"
+    
+    if args.enable_mcp:
+        os.environ["ENABLE_MCP"] = "true"
+    
+    main()