scalyclaw / scalyclaw

sudo for AI.
One mind, all channels.

ScalyClaw est le produit le plus complet du ClawFamily. Là où OpenClaw est un framework et MetaClaw une learning-plane, ScalyClaw est un produit fini : assistant IA self-hosted, multi-canal, horizontalement scalable, avec moteur proactif, dashboard React et sécurité à 4 couches.

Stars 10
Âge 14 jours
Version 0.1.0
Language TypeScript (Bun)
Canaux 7
License MIT
Queue BullMQ + Redis
Architecture

3 processus — seul Redis est partagé

Le secret de la scalabilité de ScalyClaw : les workers n'ont besoin que de Redis. Même config, machines différentes. Horizontal scaling par design.

Singleton ↑
NODE
Le cerveau unique. Normalise tous les canaux entrants, applique les guards, fait tourner l'orchestrateur LLM, gère la mémoire SQLite, planifie les messages proactifs, expose l'API Fastify.
7 channels 4 guards Orchestrator Memory SQLite Proactive Engine MCP registry Models registry Scheduler
BullMQ jobs → Redis
Horizontalement scalable (1…N)
WORKERS
Exécutent les skills et agents. Langages : JS (bun), Python (uv), Rust (cargo), Bash. Auto-install des dépendances au premier run. Hot-reload via pub/sub. Seule dépendance partagée avec le Node : Redis.
Skills execution Agent runners 4 langages Vault secrets → env vars Deploy remote ✓
Fastify HTTP
React SPA
DASHBOARD
15 vues de monitoring temps réel. Éditeur de personnalité (IDENTITY.md, SOUL.md, USER.md). Zero-downtime config via Redis pub/sub. Chat overlay pour tester sans quitter le dashboard. Job inspector (queues BullMQ live).
React 19 + Vite 6 Tailwind CSS 4 shadcn/ui 15 vues
Seul état partagé
REDIS
Queue BullMQ · Pub/Sub (hot-reload) · Vault secrets · Activity tracking · Proactive signals buffer. Si Redis tombe, tout s'arrête — single point of failure assumé.
BullMQ queues Pub/Sub reload Vault Debounce buffer
Message Journey

De l'utilisateur à la réponse

Exemple : "Generate a PDF report of AAPL stock"

1
Channel Adapter
Telegram, Discord, Slack… → normalize → InboundMessage { sender, text, channel, session }
2
Guard Pipeline (4 couches)
Echo Guard + Content Guard en parallèle → Command Shield déterministe → Skill/Agent Guard. Un seul échec = message droppé.
3
Orchestrateur LLM
Decide : use stock-price-skill + html-to-pdf-skill. Enqueue 2 BullMQ jobs dans le skills queue.
4
Worker execution
Worker consomme les jobs → uv run main.py AAPL → résultat via Redis → orchestrateur formate la réponse.
5
Memory Extraction (debounced)
Buffer Redis → BullMQ delay → LLM extrait facts, preferences, events → SQLite + sqlite-vec + FTS5.
6
Delivery
PDF envoyé sur Telegram. Response Echo Guard vérifie l'output avant envoi.
Sécurité

4 couches — toutes fail-closed par défaut

Les guards Echo + Content tournent en parallèle. Un crash isolé ne fait pas tomber les autres.

🔊
Echo Guard
LLM répercute le texte → cosine similarity. Score bas = tentative d'injection.
LLM
↓
🛡
Content Guard
LLM judge → { safe, reason, threats }. Prompt injection, social engineering, contenu nuisible.
LLM
↓
🔍
Skill / Agent Guard
Audit LLM du code SKILL.md + script à la registration. Patterns malicieux → rejet immédiat.
LLM (reg.)
↓
⚡
Command Shield
Pattern matching déterministe. rm -rf, curl | sh… bloqué instantanément. Zéro LLM, zéro latence.
Déterministe
ANY FAIL → message dropped · user notified · guards indépendants

Modèle configurable par guard

Chaque guard peut utiliser un modèle différent — un modèle rapide/pas cher pour Echo + Content, un modèle plus lourd pour Skill Guard. failOpen disponible par guard pour les contextes non-critiques.

Mémoire

SQLite triple-index — la plus sophistiquée du ClawFamily

🗄
Main Store
memories table
subject, content, type, tags, importance, TTL, access_count
🔮
Vector Search
sqlite-vec
Similarité sémantique. Premier choix de retrieval.
🔍
Full-Text Search
FTS5
Fallback si pas d'embeddings ou zéro résultat vectoriel.
🏷
Tag Index
memory_tags
Index normalisé. Requêtes par tag instantanées.

Composite Scoring

Pas juste la similarité sémantique. Score = 0.6 × semantic + 0.2 × recency_decay + 0.2 × importance. Poids configurables. Résultats bien plus pertinents.

Debounced Extraction

Buffer Redis des messages → BullMQ delay → LLM extrait fact, preference, event, relationship avec confidence score. Aucune latence par message. Cross-channel : les mémoires Telegram fonctionnent sur Discord.

Types de mémoire + métadonnées

TypeExempleConfidence
factuser is a developer0.95
preferenceprefers Python over JS0.88
eventdeployed prod on 2026-03-100.72
relationshipworks with team of 30.65
Feature unique dans le ClawFamily

Moteur proactif — 2 phases découplées

L'IA initie la conversation quand elle détecte le bon moment. Phase 1 gratuite (pas de LLM), Phase 2 coûteuse seulement si les signaux le justifient.

Phase 1
Signal Scan
cron · 0 LLM
Detect 7 signal types (déterministe)
Aggregate → trigger type
Adaptive threshold check
Timing check (quiet hours, patterns)
→ Enqueue proactive-eval job
Phase 2
Deep Evaluation
BullMQ · LLM
Re-detect signals (may have changed)
Rate limit + cooldown checks
Assemble context (memory + history)
LLM: should engage? type? confidence?
LLM: generate message
→ Deliver on best channel

7 types de signaux (Phase 1)

idle — inactif au-delà du seuil
time_sensitive — deadline en mémoire
pending_deliverable — engagement non résolu
unfinished_topic — thread non conclu
entity_trigger — entité récurrente
user_pattern — correspond aux horaires habituels
return_from_absence — retour après silence multi-jours

Adaptive Threshold

Le seuil de déclenchement s'ajuste automatiquement en fonction du taux de réponse de l'utilisateur et du sentiment des réponses (heuristique sans LLM : keyword matching + longueur > 20 chars = positif). Plus l'utilisateur répond, plus le seuil est bas. Moins il répond, plus l'IA attend.

LLM Routing

Priority + Weight — failover automatique

Priority 0 Groupe primaire — essayé en premier
claude-opus
weight: 3 → ~30%
claude-sonnet
weight: 7 → ~70%
Priority 1 Fallback — si tout le groupe P0 échoue
gpt-4o
weight: 5
Priority 2 Last resort — local/offline
local-ollama
weight: 1

Budget control

Tracking token par modèle. Limites mensuelle et journalière en mode soft (warn) ou hard (refuse au-dessus du cap). Endpoint OpenAI-compatible = tout provider : Anthropic, OpenAI, Ollama, LM Studio, MiniMax…

Pour Lyra : Anthropic API (P0) → Ollama Machine 2 (P1) — mapping direct.

Position dans l'écosystème

ScalyClaw vs ClawFamily — head-to-head

ScalyClaw n'est pas construit sur OpenClaw — c'est une implémentation parallèle complète. Même problème de base (assistant IA), résolu comme un produit fini plutôt qu'un framework.

Dimension OpenClaw IronClaw NanoClaw ScalyClaw ★
Type Framework Prod-hardened Lightweight Produit complet
Canaux Multi (framework) Multi 1-2 7
Proactif ✗ ? ✗ ✓ 2-phase engine
Dashboard ✗ ? ✗ ✓ React 19 · 15 vues
Worker scaling ✗ ? ✗ ✓ horizontal (Redis only)
Security guards Basic ? ✗ ✓ 4-layer fail-closed
Mémoire RAG-based ? SQLite ✓ SQLite + vec + FTS5
Install npm setup ? npm ✓ one-line curl
Pertinence pour Lyra

3 patterns à emprunter maintenant

Emprunts immédiats (sans Redis)

Command Shield
Pattern matching déterministe. 0 LLM, 0 latence, 0 coût. Implémentable en un fichier Python.
Priority + Weight Model Routing
Anthropic P0 → Ollama Machine 2 P1. Failover automatique, budget control. Mapping parfait avec hardware Lyra.
Proactive Engine (2-phase)
Cron scan (0 LLM) → asyncio.Queue job (LLM uniquement si signaux). Architecture budget-aware par design.

Emprunts Phase 2+ (avec Redis/workers)

BullMQ job model
Pour les tâches longues — port en Python : arq ou celery.
Worker isolation
Machine 1 (Hub, Node) → Machine 2 (AI Server, workers LLM lourds). Même pattern Redis-only.
Composite memory scoring
Ajouter recency decay + importance aux poids BM25+vec existants dans 2ndBrain.
Adaptation — Proactive Engine en Python asyncio

Le pattern 2-phase mappe parfaitement sur l'architecture Lyra

Phase 1 — Cron loop (0 LLM)
detect_signals()
→
aggregate(signals, weights)
→
adaptive_threshold?
→
queue.put(ProactiveEvalTask)
Phase 2 — Queue consumer (LLM)
queue.get()
→
rate_limit_ok?
→
assemble_context()
→
llm_should_engage?
→
deliver(best_channel)

Pas de BullMQ. Pas de Redis. asyncio.Queue suffit pour Lyra phase P0. Le pattern est identique, juste avec les primitives asyncio Python.

Risques

Ce qui peut coincer

Très tôt (0.1.0, 2 semaines)
Haut
Aucun track record en production. Les APIs vont changer. À surveiller, pas à intégrer maintenant.
Communauté faible (10 stars)
Haut
Peu de bug reports, peu de battle-testing. Mais le README est poli et la feature set complète — proche d'une annonce publique.
Redis hard dependency
Moyen
Tous les processus nécessitent Redis. Single point of failure assumé par design. Si Redis tombe, tout s'arrête.
Guards = latence + coût LLM
Moyen
Echo + Content guards sur chaque message. À l'échelle, latence et coût token significatifs. Command Shield (déterministe) compense partiellement.
Pas de RBAC multi-user
Moyen
Single-user ou groupe de confiance uniquement. Pas de séparation utilisateurs au niveau node. Non-enterprise par design.
Bun runtime
Bas
Stable mais moins battle-tested que Node. Quelques packages npm ont des incompatibilités Bun sporadiques.
Verdict

ScalyClaw est le produit le plus complet du ClawFamily. Trop jeune pour une intégration directe, mais ses patterns architecturaux sont empruntables maintenant : Command Shield · Priority+Weight routing · Proactive 2-phase engine.

Si il atteint 1k stars, il devient le Home Assistant des plateformes IA personnelles. À surveiller : si il décolle, les patterns deviennent du gold standard à suivre.