WebAssembly pour les compétences IA : Luminarys AI

Luminarys AI : Une plateforme modulaire pour des compétences IA isolées en WebAssembly

Luminarys AI est une plateforme pour déployer des agents IA dont les compétences sont isolées dans des sandboxes WebAssembly. Elle permet d'écrire des compétences en Go, Rust, AssemblyScript, de les regrouper en clusters sur des architectures hétérogènes et d'utiliser le protocole MCP. Elle répond aux défis de sécurité, de support multi-langages et de mise à l'échelle en production.

Isolation des compétences dans des sandboxes

Les compétences sont compilées en WebAssembly et exécutées avec une isolation stricte basée sur la configuration. L'accès au système de fichiers, au shell et à HTTP est restreint via des listes d'autorisation—la compétence ne peut physiquement pas dépasser ses limites. La vérification a lieu au chargement : les incohérences de configuration bloquent l'exécution.

Exemple de configuration pour la surveillance matérielle :

# Exemple : compétence pour l'interaction matérielle
id: hardware-monitor
permissions:
  fs:
    enabled: true
    dirs:
      - "/sys/class:ro"               # lecture de sysfs (capteurs, périphériques)
      - "/dev/serial:rw"              # accès aux ports série
  shell:
    enabled: true
    allowlist:
      - "lsusb **"                    # uniquement les commandes listées
      - "i2cget **"
      - "cat /proc/cpuinfo"
    allowed_dirs:
      - "/tmp/hw-monitor"

Une compétence pour la température du CPU ne voit que /sys/class/thermal, pour les GPIO—/sys/class/gpio. Pas de chaînes de commandes, pas d'échappement du sandbox.

Compétences multi-langages avec SDK

Les compétences sont écrites en Go, Rust ou AssemblyScript. Le générateur de code lmsk crée des modules WASM à partir de code annoté : routage, sérialisation, validation.

• AssemblyScript : modules compacts (~100 Ko), syntaxe TypeScript. Pour HTTP, système de fichiers, texte.
• Rust : performance, bibliothèques natives. Analyse de protobuf/PCAP, inférence ONNX, tree-sitter.
• Go : bibliothèque standard, intégration de VM JS/Python.

Exemple de compétence en Go :

// @skill:id      ai.example.hello
// @skill:name    "Hello Skill"
// @skill:version 1.0.0
// @skill:desc    "Compétence de salutation simple."
package main

import sdk "github.com/LuminarysAI/sdk-go"

// @skill:method greet "Retourne une salutation."
// @skill:param  name required "Nom de la personne"
// @skill:result "Chaîne de salutation"
func Greet(_ *sdk.Context, name string) (string, error) {
    return "Bonjour, " + name + " !", nil
}

Version Rust :

/// @skill:id      ai.example.hello
/// @skill:name    "Hello Skill"
/// @skill:version 1.0.0
/// @skill:desc    "Compétence de salutation simple."

use luminarys_sdk::prelude::*;

/// @skill:method greet "Retourne une salutation."
/// @skill:param  name required "Nom de la personne"
/// @skill:result "Chaîne de salutation"
pub fn greet(_ctx: &mut Context, name: String) -> Result<String, SkillError> {
    Ok(format!("Bonjour, {} !", name))
}

AssemblyScript :

/**
 * @skill:id      ai.example.hello
 * @skill:name    "Hello Skill"
 * @skill:version 1.0.0
 * @skill:desc    "Compétence de salutation simple."
 */
import { Context } from "@luminarys/sdk-as";

// @skill:method greet "Retourne une salutation."
// @skill:param  name required "Nom de la personne"
// @skill:result "Chaîne de salutation"
export function greet(_ctx: Context, name: string): string {
  return "Bonjour, " + name + " !";
}

Les compétences dans différents langages se chargent dans un seul hôte, s'appellent mutuellement, partagent l'état.

Regroupement en clusters sur nœuds hétérogènes

Le nœud maître route les appels vers les esclaves sur x86, ARM, RISC-V, IoT. Les compétences ne perçoivent pas le cluster—l'API est locale.

Scénarios :

• CI/CD : tests sur esclave Linux, compilation binaire Windows sur esclave Windows.
• Matériel : Raspberry Pi pour I2C, Jetson pour vidéo, x86 pour série.
• Flotte IoT : maître dans le cloud, esclaves en périphérie avec GPIO/SPI/UART.
• Surveillance : sysfs, SMART, CPU/GPU dans des sandboxes.

Le serveur relais assure le transfert de fichiers chiffré. Si un esclave échoue—mises à jour automatiques des outils.

Multi-LLM et mode agent

Routage des modèles par tâche/langage : deepseek-coder pour le code, rust-specialist pour Rust. Configuration sans redémarrage.

Mode agent (développement) :

• Lots : appels synchrones/asynchrones à plusieurs compétences.
• Autonomie : rappels sur événements (minuteries, capteurs, MQTT).
• Interaction : appels compétence→compétence avec contrôle de profondeur/délai.

Compatibilité MCP

Support du Model Context Protocol : Claude, Cursor, Open WebUI. Transports—HTTP Streamable, SSE, stdio, OpenAPI.

Points clés

• Les compétences dans des sandboxes WebAssembly empêchent les échappements de permissions.
• Support multi-langages (Go/Rust/AS) avec annotations unifiées et générateur de code.
• Le regroupement en clusters distribue la charge sur les architectures sans changer l'API.
• Compatibilité MCP pour l'intégration avec Claude/Cursor/Open WebUI.
• Modèle de rappels pour les agents en temps réel et autonomes.

— Editorial Team