RAKSHAK (Sanskrit: The Protector) is a real-time endpoint defense system that detects, analyzes, and remediates cybersecurity threats entirely on-device. It combines signature-based detection, statistical behavioral analysis for zero-day threats, AI-powered threat classification via a quantized Phi-3.5-mini ONNX model, and an ethics-first auto-patch engine that requires human approval before any action is taken.

Why it matters: Traditional endpoint security depends on cloud lookups, vendor signature databases, and internet connectivity. RAKSHAK inverts this model. It learns what "normal" looks like for every process on your machine and flags statistical deviations in real-time — catching threats that have no existing signature. It runs on commodity hardware using AMD's NPU/GPU/CPU acceleration stack, making enterprise-grade behavioral detection accessible without cloud infrastructure costs.

What makes it innovative:

• Zero-day detection without signatures — z-score statistical analysis learns per-process baselines and flags anomalies
• Fully local AI inference — Phi-3.5-mini ONNX model runs on-device via DirectML, never sends data externally
• Hardware-agnostic acceleration — auto-detects AMD Ryzen AI NPU, any DirectML GPU (AMD/NVIDIA/Intel), or CPU fallback
• Ethics-first remediation — every suggested patch requires explicit human approval before execution
• Four independent detection engines working in parallel with coordinated threat response

Modern cyberthreats are evolving faster than signature databases can update. According to the AV-TEST Institute, over 450,000 new malware variants are registered daily. Traditional antivirus solutions face three critical failures:

The gap: There is no widely available, local-first, AI-powered endpoint defense system that can detect zero-day behavioral anomalies, provide natural-language threat analysis, and suggest human-approved remediations — all running on commodity hardware without cloud infrastructure.

RAKSHAK is a two-component system:

1. Python Sentinel Backend — a multi-engine detection server that monitors all running processes, file system activity, and source code in real-time via four independent detection engines
2. Flutter Desktop Dashboard — a real-time command center connected over WebSocket that visualizes threats, system metrics, and provides one-click patch approval/rejection

The system operates on a detect-analyze-suggest-approve pipeline:

Process/File Event → Detection Engine → AI Analysis → Patch Suggestion → Human Approval → Execution

Every step is transparent. Every action requires consent. The AI explains its reasoning. The operator decides.

• Real-time process monitoring — scans all running processes every 2 seconds for suspicious names, sustained CPU abuse, and new process creation
• Filesystem surveillance — watches directories (default: TEMP) for rapid file creation bursts (ransomware indicator)
• 14 known-threat signatures — mimikatz, cobalt strike, meterpreter, ransomware, reverse shells, keyloggers, cryptominers, and more
• Sustained spike detection — requires 2+ consecutive high-CPU scans before alerting, eliminating transient spikes

• Zero-day behavioral detection — z-score statistical analysis across 7 metrics (CPU, memory, disk I/O read/write, network connections, thread count, child process spawns) with no prior signatures required
• On-device LLM inference — Phi-3.5-mini-instruct ONNX (INT4 AWQ quantized, ~2.4 GB) generates natural-language threat explanations and severity classifications
• Graceful AI degradation — if the model is unavailable, falls back to rule-based analysis with keyword matching and heuristic scoring
• Process tree forensics — traces parent chains up to 5 levels to identify the origin of suspicious activity

• 23-rule code scanner across 5 threat categories: reverse shells, credential leaks, obfuscation, exploit patterns, suspicious OS operations
• 31 file type coverage — Python, JavaScript, PowerShell, Bash, C/C++, Go, Rust, Java, config files, logs, SQL, and more
• Auto-patch engine with 8 remediation actions: process termination, network blocking, file quarantine, secret redaction, directory lockdown, process tree suspension, I/O throttling, Defender scan
• Human-in-the-loop ethics layer — no automated action is ever taken without explicit operator approval

• Animated status ring — immediate visual threat indicator (SECURE / THREAT / OFFLINE) with glowing animated arcs
• Real-time metrics dashboard — CPU sparkline chart, RAM/disk progress bars, network TX/RX counters, process count
• Defense engine telemetry — live stats for behavioral scans, code scanner findings, and patch pipeline status
• Color-coded threat feed — events tagged by detection source (THREAT / BEHAVIOR / SCAN) with severity badges
• AI console — terminal-style log with syntax-colored output for system events, AI analysis, and patch actions
• One-click patch approval — inline APPROVE/REJECT buttons with risk level and reversibility indicators

flowchart TD
    A[System Boot] --> B[Hardware Detection]
    B --> C{AMD NPU Available?}
    C -->|Yes| D[VitisAI Provider]
    C -->|No| E{DirectML GPU?}
    E -->|Yes| F[DML Provider]
    E -->|No| G[CPU Fallback]

    D --> H[Initialize Sentinel]
    F --> H
    G --> H

    H --> I[Start Detection Engines]
    I --> I1[Anomaly Sensor]
    I --> I2[Behavioral Detector]
    I --> I3[Code Scanner]
    I --> I4[AI Brain]

    I1 -->|Every 2s| J[Process Scan]
    J --> J1{Suspicious Name?}
    J1 -->|Yes| K[Emit ThreatEvent]
    J --> J2{CPU > 95% sustained?}
    J2 -->|Yes| K
    J --> J3{Rapid File Creation?}
    J3 -->|Yes| K

    I2 -->|Every 3s| L[Behavioral Scan]
    L --> L1[Collect Metrics per Process]
    L1 --> L2[Calculate Z-Score vs Baseline]
    L2 --> L3{Z > 3.5 sigma AND\nabove absolute threshold?}
    L3 -->|Yes| M[Emit BehaviorAnomaly]

    I3 -->|Every 10s| N[File System Scan]
    N --> N1[Scan New/Modified Files]
    N1 --> N2{Pattern Match\n23 Rules?}
    N2 -->|Yes| O[Emit ScanFinding]

    K --> P[AI Brain Analysis]
    M --> P
    O --> P

    P --> Q{ONNX Model\nLoaded?}
    Q -->|Yes| R[Phi-3.5-mini Inference]
    Q -->|No| S[Rule-Based Analysis]

    R --> T[Generate Verdict + Explanation]
    S --> T

    T --> U[Patch Engine]
    U --> V[Generate Remediation Suggestions]
    V --> W[WebSocket Broadcast]

    W --> X[Flutter Dashboard]
    X --> Y[Operator Reviews]
    Y --> Y1[APPROVE]
    Y --> Y2[REJECT]

    Y1 --> Z[Execute Patch]
    Y2 --> Z2[Log Rejection]

graph LR
    subgraph Actors
        OP((Security<br>Operator))
        SYS((System<br>Processes))
        ATK((Threat<br>Actor))
    end

    subgraph "RAKSHAK System"
        UC1[Monitor Running Processes]
        UC2[Detect Behavioral Anomalies]
        UC3[Scan Code for Malicious Patterns]
        UC4[Classify Threat via AI]
        UC5[Generate Patch Suggestions]
        UC6[Approve / Reject Patches]
        UC7[View Real-Time Dashboard]
        UC8[Review AI Analysis]
        UC9[Run Threat Simulations]
        UC10[Download AI Model]
        UC11[View System Metrics]
        UC12[Review Threat History]
    end

    SYS --> UC1
    SYS --> UC2
    ATK -.->|triggers| UC1
    ATK -.->|triggers| UC2
    ATK -.->|triggers| UC3

    UC1 --> UC4
    UC2 --> UC4
    UC3 --> UC4
    UC4 --> UC5

    OP --> UC6
    OP --> UC7
    OP --> UC8
    OP --> UC9
    OP --> UC10
    OP --> UC11
    OP --> UC12

+------------------------------------------------------------------+
| [*] RAKSHAK  [MVP]              [AMD GPU via DirectML] [ONLINE]  |
+------------------------------------------------------------------+
|                    |                                              |
|   +------------+  |  THREAT FEED                            [3]  |
|   |            |  |  +------------------------------------------+|
|   |  SECURE /  |  |  | CRITICAL  THREAT  mimikatz.exe   PID:481 ||
|   |  THREAT /  |  |  | Mimikatz-class credential harvesting     ||
|   |  OFFLINE   |  |  | > IMMEDIATELY terminate the process      ||
|   |   (ring)   |  |  +------------------------------------------+|
|   |            |  |  | HIGH  BEHAVIOR  svchost.exe      PID:772 ||
|   +------------+  |  | CPU usage jumped to 98.2% (baseline 2.1%)||
|                    |  | > Terminate the process                  ||
|   SYSTEM VITALS    |  +------------------------------------------+|
|   ~~~~~~~~~~~~~~   |  | MEDIUM  SCAN  config.py     line:42     ||
|   CPU  [====  ] 23%|  | Hardcoded password detected              ||
|   RAM  [======] 61%|  | > Remove secrets from source             ||
|   DISK [=======]72%|  +------------------------------------------+|
|   NET   TX 142 MB  |                                              |
|   PROCS      287   |  +--2 PATCHES AWAITING APPROVAL-------------+|
|                    |  | LOW  kill_process: mimikatz  [APPROVE]    ||
|   DEFENSE ENGINES  |  | LOW  defender_scan: C:\     [REJECT]     ||
|   ~~~~~~~~~~~~~~~  |  +------------------------------------------+|
|   Behavioral       |                                              |
|    142 scans | 3   |  AI CONSOLE                          [LIVE] |
|   Scanner          |  +------------------------------------------+|
|    89 files | 1    |  | [09:41:02] [SYS] Connected to Rakshak v2 ||
|   Patches          |  | [09:41:02] [HW]  Device: GPU (AMD)       ||
|    5 sugg | 2 app  |  | [09:41:15] [THREAT] CRITICAL | mimikatz  ||
|                    |  | [09:41:15] [AI] Mimikatz-class credential ||
|   UPTIME  4m 32s   |  | [09:41:15] [PATCH] PATCH-0001 | kill...  ||
|                    |  +------------------------------------------+|
+------------------------------------------------------------------+

+------------------------------------------------------+
| CRITICAL   THREAT   mimikatz.exe           PID: 4812 |
|                                          rule-based   |
|------------------------------------------------------|
| Mimikatz-class credential harvesting tool detected.   |
| Capable of extracting plaintext passwords from        |
| memory. This is a known post-exploitation tool used   |
| in advanced persistent threats.                       |
|                                                       |
| > IMMEDIATELY terminate the process and isolate the   |
|   host from the network.                              |
+------------------------------------------------------+

+------------------------------------------------------+
| [!] 2 PATCHES AWAITING APPROVAL      Human Required  |
|------------------------------------------------------|
| MEDIUM  kill_process: mimikatz.exe (PID 4812)        |
|         [undo] [APPROVE] [REJECT]                    |
|                                                       |
| LOW     defender_scan: C:\                            |
|               [APPROVE] [REJECT]                     |
+------------------------------------------------------+

graph TB
    subgraph "Frontend Layer - Flutter Desktop"
        FE1[DashboardScreen<br>Two-panel layout]
        FE2[StatusRing<br>Animated threat indicator]
        FE3[MetricsPanel<br>System vitals + CPU chart]
        FE4[ThreatList<br>Event feed + patch approval]
        FE5[AIConsole<br>Terminal-style log]
        FE6[SentinelService<br>WebSocket client + state mgmt]
    end

    subgraph "Communication Layer"
        WS[WebSocket Server<br>ws://127.0.0.1:8765<br>JSON protocol]
    end

    subgraph "Backend Layer - Python Sentinel"
        SRV[server.py<br>Async WebSocket API v2.0]
        SRV --> EQ[Event Queue<br>asyncio.Queue]
        SRV --> MB[Metrics Broadcaster<br>2s interval]
    end

    subgraph "Detection Layer - Four Engines"
        E1[AnomalySensor<br>Process names + CPU + filesystem<br>2s scan interval]
        E2[BehavioralDetector<br>Z-score statistical analysis<br>3s scan interval]
        E3[CodeScanner<br>23 regex rules, 31 file types<br>10s scan interval]
        E4[AIBrain<br>Phi-3.5-mini ONNX<br>or rule-based fallback]
    end

    subgraph "Response Layer"
        PE[PatchEngine<br>8 remediation actions]
        PM[PatchManager<br>Approval state machine]
    end

    subgraph "Hardware Abstraction Layer"
        HD[hardware_detect.py<br>Provider selection]
        HD --> NPU[AMD Ryzen AI NPU<br>VitisAIExecutionProvider]
        HD --> GPU[DirectML GPU<br>AMD / NVIDIA / Intel]
        HD --> CPU[CPU Fallback<br>CPUExecutionProvider]
    end

    FE6 <-->|JSON over WS| WS
    WS <--> SRV

    E1 -->|ThreatEvent| EQ
    E2 -->|BehaviorAnomaly| EQ
    E3 -->|ScanFinding| EQ
    EQ --> E4
    E4 --> PE
    PE --> PM

    HD --> E4

rakshak/
├── sentinel/                           # Python Backend (Detection Server)
│   ├── server.py                       #   WebSocket API server v2.0.0-mvp
│   ├── anomaly_sensor.py               #   Process + filesystem monitoring
│   ├── behavioral_detector.py          #   Z-score behavioral analysis engine
│   ├── code_scanner.py                 #   23-rule pattern scanner
│   ├── ai_brain.py                     #   Phi-3.5-mini ONNX inference + fallback
│   ├── patch_engine.py                 #   Auto-remediation suggestion engine
│   ├── hardware_detect.py              #   NPU / GPU / CPU detection
│   ├── mock_threat.py                  #   5-scenario threat simulator
│   ├── download_model.py              #   HuggingFace model downloader
│   └── models/phi3.5-mini/             #   ONNX model directory (downloaded)
│
├── flutter_dashboard/                  # Flutter Desktop Dashboard
│   ├── lib/
│   │   ├── main.dart                   #   App entry + theme configuration
│   │   ├── services/
│   │   │   └── sentinel_service.dart   #   WebSocket client + state management
│   │   └── widgets/
│   │       ├── dashboard_screen.dart   #   Two-panel layout + top bar
│   │       ├── threat_list.dart        #   Threat feed + patch approval UI
│   │       ├── metrics_panel.dart      #   System vitals + defense engine stats
│   │       ├── status_ring.dart        #   Animated threat level indicator
│   │       └── ai_console.dart         #   Terminal-style event log
│   ├── windows/                        #   Native Windows runner (CMake)
│   ├── pubspec.yaml                    #   Flutter dependencies
│   └── test/widget_test.dart           #   Smoke test
│
├── pyproject.toml                      # Python project config
├── requirements.txt                    # Python dependencies
└── README.md

pip install -r requirements.txt

python -m sentinel.server

========================================================
   RAKSHAK v2.0 - AI Cybersecurity Sentinel
   Local-First | Behavioral AI | Zero-Day Detection
========================================================
[INFO] Hardware: GPU (AMD) via DirectML
[INFO] AI Engine: rule-based (model not downloaded)
[INFO] Features: behavioral, code_scanner, patch_engine, ethics_layer
[INFO] WebSocket server listening on ws://127.0.0.1:8765

cd flutter_dashboard
flutter run -d windows

pip install onnxruntime-genai-directml huggingface-hub
python -m sentinel.download_model

Downloads Phi-3.5-mini-instruct ONNX (~2.4 GB, INT4 AWQ quantized). System works without it using rule-based + behavioral engines.

python -m sentinel.mock_threat                    # All 5 scenarios
python -m sentinel.mock_threat --scenario cpu      # Single scenario
python -m sentinel.mock_threat --no-cleanup        # Keep artifacts for forensics

Statistical z-score analysis across 7 per-process metrics:

False positive elimination:

Coverage: 31 file extensions. Max file size: 1 MB. Skips node_modules, __pycache__, .git, venv, build, dist.

Fallback chain: Phi-3.5-mini ONNX (best) -> Rule-based keyword engine (always available)

Key advantage: $0 cloud cost. No per-endpoint licensing. No data egress fees. The entire system runs on hardware the organization already owns.

Phase 2 — Enterprise Features

• Central fleet management dashboard (multi-endpoint)
• SIEM integration (Splunk, Elastic, Sentinel)
• Active Directory / SSO authentication for patch approval
• Encrypted WebSocket (wss://) with TLS mutual auth

Phase 3 — Advanced AI

• Fine-tune Phi-3.5-mini on organization-specific threat telemetry
• Multi-model ensemble (behavioral model + code analysis model + NLP model)
• Federated learning across endpoints without sharing raw data
• AMD Ryzen AI NPU-optimized model quantization (INT4 → INT2)

Phase 4 — Platform Expansion

• Linux agent using eBPF for kernel-level process monitoring
• macOS agent using Endpoint Security Framework
• ARM64 support for edge/IoT deployment
• Container/Kubernetes workload monitoring

RAKSHAK combines four techniques that are individually well-known but rarely integrated into a single, local-first system:

1. Statistical behavioral detection (z-score) — used in network IDS but rarely applied at the per-process level on endpoints
2. On-device LLM inference — commercial EDR products use cloud AI; RAKSHAK runs Phi-3.5-mini locally via DirectML
3. Hardware-agnostic NPU/GPU/CPU cascade — automatically selects the best available accelerator without configuration
4. Ethics-first auto-remediation — AI suggests, human decides; every patch is tracked, auditable, and reversible

This is not a concept. It is a working system:

• Backend and dashboard build and run on Windows 10/11
• All 4 detection engines operate concurrently in production
• 5 realistic attack simulations validate detection coverage
• AI model downloads from HuggingFace and runs inference on commodity GPUs
• False positive rate reduced to near-zero through warmup, cooldowns, absolute thresholds, and whitelists