🧠 Axioma KAN System v1.5

Complete KAN lifecycle management for OpenClaw agents.

Overview

This skill provides complete KAN (Kolmogorov-Arnold Networks) lifecycle management for the Axioma cluster:

• Create new KAN concepts and architectures
• Train KAN models with PyTorch
• Assemble KAN pipelines and connections
• Monitor KAN health and auto-evolve
• Integrate T-KAN for memory enhancement

Table of Contents

1. Purpose — Overview and goals
2. When to Use — Trigger scenarios
3. Prerequisites — Requirements
4. Tools — Core scripts
5. Quick Start — Getting started
6. KAN Core Concepts — Technical details
7. Error Handling — Troubleshooting
8. Constraints — Limitations
9. Performance — Benchmarks
10. Related Files — File structure
11. References — Resources
12. Support — Help and contact

1. Purpose

Axioma KAN System is the cluster's core intelligent infrastructure providing complete KAN lifecycle management:

2. When to Use

3. Prerequisites

3.1 Installation Commands

# Install PyTorch (CPU or GPU)
pip3 install torch>=1.9

# Install numpy for data processing
pip3 install numpy

# Install Qdrant client
pip3 install qdrant-client

# Verify all installations
python3 -c "import torch; import numpy; import qdrant_client; print('All OK')"

Note: PyTorch is required for all KAN operations (training, inference, model manipulation).

3.2 Environment Variables

4. Tools

Core Scripts

External Integration

5. Quick Start

5.1 Create a KAN Concept

cd <skill-directory>
python3 scripts/kan_creator.py --name my_watchdog --role "monitoring"

Expected output:

✅ KAN concept 'my_watchdog' created
📁 Directory: scripts/my_watchdog/
📋 Config: scripts/my_watchdog/config.json
🧠 Model: scripts/my_watchdog/models/my_watchdog_kan.pt

5.2 Train a KAN Model

# Train specific KAN
python3 scripts/kan_trainer.py --kan stc --epochs 50 --batch-size 32

# Check health
python3 scripts/kan_trainer.py --check-health

Expected output:

🔄 Training stc...
    Epoch 10/50: Loss = 0.0856
    Epoch 20/50: Loss = 0.0233
    Epoch 50/50: Loss = 0.0175
✅ stc trained and saved!

Python API:

from kan_trainer import KANTrainer

trainer = KANTrainer(kan_name='stc')
trainer.train(epochs=50, batch_size=32)
health = trainer.check_health()
print(f'KAN health: {health}')

5.3 Assemble KAN Pipeline

# Create KAN pipeline
python3 scripts/kan_assembler.py --pipeline "stc→syn→w7" --output pipeline.json

# Connect two KANs
python3 scripts/kan_assembler.py --connect stc --with flx --mode serial

# List all KANs
python3 scripts/kan_assembler.py --list

5.4 Health Check

# Check all KANs
cd <skill-directory>
python3 scripts/kan_health.py --all

# Run test suite (5/5 tests MUST PASS)
python3 tests/test_kan_system.py

Expected output:

╔═══════════════════════════════════════════════════════════╗
║  🏥 KAN HEALTH CHECK                                      ║
╠═══════════════════════════════════════════════════════════╣
║  ✅ stc — HEALTHY — Loss 0.0175 within threshold          ║
║  ✅ syn — HEALTHY — Loss 0.0152 within threshold          ║
║  ❌ clw — DEGRADED — Loss 0.1245 > 0.1 threshold         ║
║  💡 clw needs retraining                                 ║
╚═══════════════════════════════════════════════════════════╝

5.5 Unified Watchdog Trainer (NEW!)

Train all 19 KANs at once with the unified trainer:

# Train ALL 19 KANs (14 watchdogs + 5 L9 Swarm)
cd <skill-directory>
python3 scripts/watchdog_unified_trainer.py --all --epochs 200 --samples 300

# Check status of all KANs
python3 scripts/watchdog_unified_trainer.py --status

# Train specific KAN
python3 scripts/watchdog_unified_trainer.py --kan STC --epochs 100

# Train only watchdogs (14)
python3 scripts/watchdog_unified_trainer.py --watchdogs

# Train only L9 Swarm (5)
python3 scripts/watchdog_unified_trainer.py --swarm

19 KANs covered:

Note: <AGENT_A>, <AGENT_B>, <AGENT_C> represent agent-specific workspace directories. <KAN_SWARM> represents the L9 Deep Memory Swarm directory.

Cron schedule: Training nightly at 2AM, status check at 8AM

6. KAN Core Concepts

What is KAN?

╔═══════════════════════════════════════════════════════════╗
║  KAN = Kolmogorov-Arnold Networks                         ║
╠═══════════════════════════════════════════════════════════╣
║                                                           ║
║  Traditional MLP: y = σ(Wx + b)                          ║
║  KAN:          y = Σφᵢₙ(xᵢ)                             ║
║                                                           ║
║  Difference: KAN uses learnable activation functions     ║
║  instead of fixed ones. Each weight is a function, not    ║
║  a scalar.                                               ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝

KAN Architecture Parameters

7. Error Handling

Connection Errors

Model Errors

Training Errors

8. Constraints

KAN Limits

Training Limits

Technical Requirements

9. Performance Benchmarks

10. Related Files

Core Files

Integration Files

Troubleshooting

Q: KAN training fails with CUDA error? A: Use CPU mode: python3 scripts/kan_trainer.py --kan stc --device cpu

Q: Qdrant connection refused? A: Check Qdrant is running: sudo systemctl status qdrant

Q: KAN not auto-evolving? A: Check the cron job: crontab -l and ensure kan_auto_task.py is scheduled

Q: Low KAN quality score? A: Run retraining: python3 scripts/kan_trainer.py --kan <name> --epochs 1000 --auto-evolve

Q: Model file not found? A: Check models/ directory exists and has .pt files

11. References

For detailed information, see:

11.1 Advanced: LLM → KAN Knowledge Transfer

DISCOVERED 2026-05-13 — A breakthrough pattern for building efficient KANs using LLM as "cobaye" (teacher):

╔═══════════════════════════════════════════════════════════╗
║  💡 LLM → KAN KNOWLEDGE TRANSFER PATTERN                 ║
╠═══════════════════════════════════════════════════════════╣
║                                                           ║
║  LLM (COBAYE) → Generates diverse training examples      ║
║       ↓                                                   ║
║  KAN (APPRENTI) → Learns patterns from examples          ║
║       ↓                                                   ║
║  KAN standalone → Operates WITHOUT LLM, faster + cheaper ║
║                                                           ║
╚═══════════════════════════════════════════════════════════╝

Why This Works

Use Cases

Implementation Pattern

# 1. Generate diverse examples using LLM (cobaye)
python3 generate_diverse_data.py --llm gemma3:1b --count 100 --output data/examples.json

# 2. Train KAN on those examples
python3 kan_trainer.py --kan flx_privacy --examples data/examples.json --epochs 5000

# 3. Use KAN standalone (no LLM needed!)
python3 flx_privacy_filter.py --input "SSN 123-45-6789"  # Returns HIGH-RISK directly

FLX Privacy Example (Tested)

Gemma 3 1B (cobaye) → Generated 97 privacy examples
                              ↓
                    FLX KAN trained (8000 epochs)
                              ↓
         FLX KAN detects: SAFE/SENSITIVE/HIGH-RISK
         WITHOUT Gemma — 3/3 official tests PASSED ✅

Code Template: LLM to KAN Transfer

from flx_privacy_trainer import PrivacyFLXKAN, message_to_features

# After training, use KAN alone (no LLM needed!)
model = PrivacyFLXKAN()
checkpoint = torch.load('models/privacy_flx.pth')
model.load_state_dict(checkpoint['model_state_dict'])
model.eval()

# Fast inference (<1ms vs 100ms for LLM)
text = "The SSN is 123-45-6789"
features = message_to_features(text)
prediction = model(features)  # No LLM calls!

Benefits Summary

In Altum Per KAN. 🧠 AXIOMA KAN SYSTEM v1.5 — 19 KANs UNIFIED TRAINER + LLM→KAN TRANSFER

License: MIT License

12. Support

For help with the Axioma KAN System:

Quick Help Commands

# Check KAN status
python3 scripts/kan_health.py

# List all KANs
python3 scripts/kan_assembler.py --list

# Check training logs
cat logs/kan_training.log

# Verify installation
python3 -c "import torch; print(f'PyTorch {torch.__version__}')"

Changelog