The first agentic operating system for AI workstations.

ruOS doesn't just respond to commands — it observes, reasons, and acts on its own behalf. A local Qwen2.5-3B model reasons about system state every 15 minutes, using RAG from a brain with 600+ memories. It monitors its own health, switches GPU profiles, trains itself overnight, embeds new knowledge during idle time, scans for prompt injection, senses physical presence via WiFi, and updates itself from GitHub releases. All local. No cloud. No external API calls.

Traditional operating systems wait. ruOS decides — with LLM reasoning.

All coordinated by a single daemon: ruos-agent.

┌────────────────────────────────────────────────────────────────┐
│  Claude Code + CLAUDE.md + .mcp.json       (agentic IDE)      │
├────────────────────────────────────────────────────────────────┤
│  ruos-agent        ruos-update        AIDefence               │
│  (heartbeat)       (OTA)              (security guard)        │
├────────────────────────────────────────────────────────────────┤
│  ruos-llm-serve (Qwen2.5-3B, CUDA)   (local LLM reasoning)  │
├────────────────────────────────────────────────────────────────┤
│  102 MCP tools (stdio)  │  22 brain tools (HTTP loopback)     │
├─────────────────────────┴──────────────────────────────────────┤
│  ruvultra-mcp       ruvultra-profile      ruvultra-init       │
│  (Rust, stdio)      (Rust, sudo)          (Rust, CLI)         │
├────────────────────────────────────────────────────────────────┤
│  mcp-brain-server   ruvultra-embedder     train_dpo.py        │
│  (DiskANN + SQLite) (candle-cuda, NVML)   (trl + peft)        │
├────────────────────────────────────────────────────────────────┤
│  brain.rvf          adapters/             profiles/           │
│  (cognitive store)  (LoRA weights)        (system TOML)       │
├────────────────────────────────────────────────────────────────┤
│  ESP32 CSI bridge   ed25519 identity      GPU (CUDA)          │
│  (WiFi sensing)     (node keys)           (RTX/Jetson)        │
├────────────────────────────────────────────────────────────────┤
│  Linux kernel + NVIDIA driver + systemd                       │
└────────────────────────────────────────────────────────────────┘

         ┌──────────┐
    ┌───►│ OBSERVE  │ GPU util, temp, processes, presence, time
    │    └────┬─────┘
    │         ▼
    │    ┌──────────┐
    │    │ REASON   │ Qwen2.5-3B + RAG from brain + AIDefence scan
    │    └────┬─────┘
    │         ▼
    │    ┌──────────┐
    │    │  DECIDE  │ Which profile? Train now? Backfill? Alert?
    │    └────┬─────┘
    │         ▼
    │    ┌──────────┐
    └────┤   ACT    │ Switch profile, restart service, embed, train
         └──────────┘
              │
         every 5 min (LLM every 15 min)

Built-in AI security layer protects the brain and agent:

• 32 injection patterns: instruction override, jailbreak, DAN mode, system prompt extraction
• 6 PII detectors: email, phone, SSN, credit card, IP address, API keys
• Unicode homoglyph normalization: Cyrillic spoofing protection
• RAG scanning: brain search results scanned before entering LLM context
• LLM output validation: agent decisions validated against action allowlist
• <0.1ms latency: pure Python regex, no external service

ruos-agent --security test     # run 6-category threat detection test
ruos-agent --security status   # show guard state + audit stats
ruos-agent --security "text"   # scan arbitrary text

The machine learns from its own corrections — fully autonomous:

Brain memories ──→ Nightly export ──→ Preference pairs (JSONL)
      ▲                                       │
      │                                       ▼
  ruos-agent                           DPO training (trl + peft)
  backfills vectors                           │
  monitors health                             ▼
  LLM reasons                         LoRA adapter (18 MB)
  AIDefence scans                             │
                                              ▼
                                       Improved inference

• Export: nightly cron extracts chosen/rejected pairs from brain corrections
• Train: train_dpo.py fine-tunes TinyLlama-1.1B with LoRA (r=16, beta=0.1)
• Result: 100% eval accuracy, reward margin 13.96, loss 0.081 on 205 pairs
• Schedule: fully autonomous — export at 3 AM, train, eval, no human needed

ruOS updates itself from GitHub releases:

ruos-update --check     # see if update is available
ruos-update             # download + install latest
ruos-update --force     # reinstall current version

• Checks cognitum-one/ruOS releases weekly
• Downloads arch-specific .deb packages via gh CLI
• Stops services → installs → restarts (zero-downtime for brain data)
• Records update event in brain memory for audit trail

ruOS uses RVF (RuVector Format) as the native brain storage:

• Append-only cognitive containers with per-segment XXH3-128 hash chains
• 8 segment types: Memory, Vector, Manifest, Metadata, Delta, Snapshot, Tombstone, Extension
• DiskANN Vamana graph index (brute force <2K vectors, graph search above)
• Ed25519 signing for provenance
• Portable: cp brain.rvf /media/usb/ is a complete brain backup

The interactive bootstrapper auto-detects hardware and deploys the right configuration:

bash scripts/ruos-bootstrap              # interactive wizard
bash scripts/ruos-bootstrap --role workstation   # direct deploy
bash scripts/ruos-bootstrap --status             # show deployment state

# Node A: primary (serves brain data)
ruos-bootstrap --role cluster-primary

# Node B: secondary (auto-discovers primary via mDNS)
ruos-bootstrap --role cluster-secondary

# Node C: secondary (explicit primary address)
ruos-bootstrap --role cluster-secondary --primary 192.168.1.100:9878

Federation uses QUIC for brain sync, ed25519 for node authentication, and last-writer-wins conflict resolution. See ADR-SYS-0011.

sudo dpkg -i ruos-core_*.deb ruos-brain-base_*.deb ruos-embedder_*.deb ruos-desktop_*.deb
ruvultra-init setup

sudo dpkg -i ruos-core_*_arm64.deb ruos-brain-base_*.deb
ruvultra-init setup --role cognitum-secondary

docker compose up -d                                # CPU-only
docker compose -f docker-compose.gpu.yml up -d      # with NVIDIA GPU

bash scripts/create-bootable-usb.sh /mnt/usb
# Then on target machine:
bash /media/usb/ruos-installer/install.sh

make all          # build amd64 + arm64 binaries
make deb          # package .debs
make deb-brain    # package pre-trained brain (RVF)
make deb-embedder # package CUDA embedder + model
make deb-desktop  # package Tauri desktop app
make test-docker  # test amd64 install in Docker
make test-arm64   # test arm64 via QEMU emulation
make release      # build + package + test everything

The MCP server exposes 102 tools over stdio JSON-RPC 2.0 + 22 brain HTTP tools:

ruos-bootstrap              # deploy wizard (7 roles)
ruos-bootstrap --status     # show deployment state
ruos-agent                  # run agentic heartbeat now
ruos-agent --status         # show agent state + LLM reasoning
ruos-agent --eval           # run self-evaluation
ruos-agent --backfill       # embed unvectorized memories
ruos-agent --train          # force DPO training now
ruos-agent --security test  # run AIDefence test suite
ruos-update --check         # check for OTA updates
ruvultra-init status        # system overview
ruvultra-profile apply gpu-train  # manual profile switch

Optional perception layer using ESP32-S3 nodes ($9 each):

• Presence detection, vital signs (breathing/heart rate), activity recognition
• WiFi CSI (Channel State Information) — no cameras, through walls
• Data flows as RVF segments into the brain for searchable sensor history
• Agent daemon uses presence data for automatic profile switching

19 ADRs document every design choice:

• Platform: cognitum-one/ruVultra (MCP server, desktop app, ADRs)
• RuView: ruvnet/RuView (WiFi sensing firmware)
• Cognitum: cognitum.one

MIT