WebAssembly para habilidades de IA: Luminarys AI

Luminarys AI: Una Plataforma Modular para Habilidades de IA Aisladas en WebAssembly

Luminarys AI es una plataforma para desplegar agentes de IA con habilidades aisladas en sandboxes de WebAssembly. Admite escribir habilidades en Go, Rust y AssemblyScript, clustering en arquitecturas heterogéneas y el protocolo MCP. Aborda desafíos de seguridad, soporte multilingüe y escalabilidad en producción.

Aislamiento de Habilidades en Sandboxes

Las habilidades se compilan en WebAssembly y se ejecutan con aislamiento estricto según la configuración. El acceso a FS, shell y HTTP se restringe mediante listas de permisos—la habilidad físicamente no puede exceder sus límites. La verificación ocurre al cargar: discrepancias en la configuración bloquean la ejecución.

Ejemplo de configuración para monitoreo de hardware:

# Ejemplo: habilidad para interacción con hardware
id: hardware-monitor
permissions:
  fs:
    enabled: true
    dirs:
      - "/sys/class:ro"               # leer sysfs (sensores, dispositivos)
      - "/dev/serial:rw"              # acceso a puertos serie
  shell:
    enabled: true
    allowlist:
      - "lsusb **"                    # solo comandos listados
      - "i2cget **"
      - "cat /proc/cpuinfo"
    allowed_dirs:
      - "/tmp/hw-monitor"

Una habilidad para temperatura de CPU solo ve /sys/class/thermal, para GPIO—/sys/class/gpio. Sin cadenas de comandos, sin escape del sandbox.

Habilidades Multilingües con SDK

Las habilidades se escriben en Go, Rust o AssemblyScript. El generador de código lmsk crea módulos WASM a partir de código anotado: enrutamiento, serialización, validación.

• AssemblyScript: módulos compactos (~100 KB), sintaxis TS. Para HTTP, FS, texto.
• Rust: rendimiento, bibliotecas nativas. Análisis de protobuf/PCAP, inferencia ONNX, tree-sitter.
• Go: stdlib, incrustación de VM JS/Python.

Ejemplo de habilidad en Go:

// @skill:id      ai.example.hello
// @skill:name    "Hello Skill"
// @skill:version 1.0.0
// @skill:desc    "Simple greeting skill."
package main

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

// @skill:method greet "Return a greeting."
// @skill:param  name required "Person name"
// @skill:result "Greeting string"
func Greet(_ *sdk.Context, name string) (string, error) {
    return "Hello, " + name + "!", nil
}

Versión en Rust:

/// @skill:id      ai.example.hello
/// @skill:name    "Hello Skill"
/// @skill:version 1.0.0
/// @skill:desc    "Simple greeting skill."

use luminarys_sdk::prelude::*;

/// @skill:method greet "Return a greeting."
/// @skill:param  name required "Person name"
/// @skill:result "Greeting string"
pub fn greet(_ctx: &mut Context, name: String) -> Result<String, SkillError> {
    Ok(format!("Hello, {}!", name))
}

AssemblyScript:

/**
 * @skill:id      ai.example.hello
 * @skill:name    "Hello Skill"
 * @skill:version 1.0.0
 * @skill:desc    "Simple greeting skill."
 */
import { Context } from "@luminarys/sdk-as";

// @skill:method greet "Return a greeting."
// @skill:param  name required "Person name"
// @skill:result "Greeting string"
export function greet(_ctx: Context, name: string): string {
  return "Hello, " + name + "!";
}

Habilidades en diferentes lenguajes se cargan en un solo host, se llaman entre sí, comparten estado.

Clustering en Nodos Heterogéneos

El nodo maestro enruta llamadas a esclavos en x86, ARM, RISC-V, IoT. Las habilidades no notan el cluster—la API es local.

Escenarios:

• CI/CD: pruebas en esclavo Linux, compilación de binario Windows en esclavo Windows.
• Hardware: Raspberry Pi para I2C, Jetson para video, x86 para serie.
• Flota IoT: maestro en la nube, esclavos en el edge con GPIO/SPI/UART.
• Monitoreo: sysfs, SMART, CPU/GPU en sandboxes.

El servidor de retransmisión asegura transferencia de archivos cifrada. Si un esclavo falla—actualizaciones automáticas de herramientas.

Multi-LLM y Modo Agente

Enrutamiento de modelos por tarea/idioma: deepseek-coder para código, rust-specialist para Rust. Configuración sin reinicio.

Modo agente (desarrollo):

• Lotes: llamadas síncronas/asíncronas a múltiples habilidades.
• Autonomía: devoluciones de llamada en eventos (temporizadores, sensores, MQTT).
• Interacción: llamadas habilidad→habilidad con control de profundidad/tiempo de espera.

Compatibilidad con MCP

Soporte para Model Context Protocol: Claude, Cursor, Open WebUI. Transportes—HTTP Streamable, SSE, stdio, OpenAPI.

Puntos Clave

• Habilidades en sandboxes de WebAssembly previenen escapes de permisos.
• Soporte multilingüe (Go/Rust/AS) con anotaciones unificadas y generador de código.
• Clustering distribuye carga entre arquitecturas sin cambios en la API.
• Compatibilidad con MCP para integración con Claude/Cursor/Open WebUI.
• Modelo de devoluciones de llamada para agentes en tiempo real y autónomos.

— Editorial Team