Cuando ClawHub se lanzó, parecía la forma obvia de extender un runtime de agente de IA. Un marketplace de skills —instala lo que necesitas, omite lo que no, contribuye con las tuyas. El modelo funcionó para las extensiones del navegador, para los plugins de VS Code, para los paquetes npm. ¿Por qué no para los agentes de IA?
A principios de 2026, la respuesta era clara. Los investigadores de seguridad encontraron que el 41,7% de las skills publicadas en ClawHub contenían vulnerabilidades. Cientos eran directamente maliciosas. El modelo de plugins, resultó, tiene un problema fundamental cuando se aplica a software que corre con permisos elevados en tu máquina.
ZeroClaw fue diseñado con este modo de fallo en mente. En lugar de un sistema de plugins, usa traits de Rust.
Qué está mal con los sistemas de plugins en tiempo de ejecución
El problema central con los sistemas de plugins tradicionales no es la calidad de la implementación —es el modelo en sí. Cuando instalas un plugin, estás descargando código de internet y ejecutándolo dentro del proceso de tu aplicación, con los permisos de tu aplicación. El plugin puede leer tus archivos, acceder a tu red, leer tus variables de entorno y hacer cualquier otra cosa que tu aplicación pueda hacer.
Los modos de fallo específicos son predecibles. La carga de código en tiempo de ejecución significa que los plugins ejecutan código arbitrario en el proceso host. La confianza por defecto significa que una vez instalado un plugin, tiene los mismos permisos que la aplicación host. Los ataques a la cadena de suministro son trivialmente fáciles: publica un paquete con un nombre similar a uno popular, espera a que los usuarios lo instalen.
Traits: un modelo diferente
Un trait de Rust es un contrato de interfaz aplicado por el compilador. Define qué métodos debe proporcionar una implementación, qué tipos aceptan esos métodos y qué garantías de seguridad de hilos deben cumplir. Aquí está el trait de canal de ZeroClaw, simplificado:
```rust
pub trait Channel: Send + Sync + 'static {
fn name(&self) -> &str;
async fn connect(&mut self) -> Result<()>;
async fn receive(&self) -> Result
Cada canal —Telegram, Discord, WhatsApp, Signal, Matrix, IRC— implementa este trait. El compilador garantiza la seguridad de tipos, la seguridad de hilos y la completitud.
Críticamente: los nuevos canales se compilan en el binario, no se cargan en tiempo de ejecución. No hay inyección de código, no hay carga dinámica, no hay decisión de confianza que tomar en el momento de la instalación.
Añadir un nuevo canal
La experiencia práctica de extender ZeroClaw es implementar el trait. Aquí está cómo se ve un adaptador de canal Matrix:
```rust pub struct MatrixChannel { homeserver: String, client: MatrixClient, }
impl Channel for MatrixChannel { fn name(&self) -> &str { "matrix" }
async fn connect(&mut self) -> Result<()> { self.client = MatrixClient::new(&self.homeserver).await?; self.client.login().await?; Ok(()) }
async fn receive(&self) -> Result
async fn send(&self, msg: Response) -> Result<()> { self.client.send_text(&msg.channel_id, &msg.text).await?; Ok(()) }
async fn disconnect(&self) -> Result<()> { self.client.logout().await } } ```
Eso son aproximadamente 50 líneas para un adaptador de canal completo. El compilador verifica que la implementación es correcta antes de que el código se distribuya.
El mismo patrón para cada punto de extensión
ZeroClaw usa traits para cada lugar donde el sistema necesita ser extensible. Los proveedores de IA implementan un trait `Provider`. Las herramientas implementan un trait `Tool` que requiere declarar permisos por adelantado:
```rust
pub trait Tool: Send + Sync {
fn name(&self) -> &str;
fn description(&self) -> &str;
async fn execute(&self, args: Value) -> Result
Cada herramienta declara lo que necesita —acceso a archivos, acceso a la red, rutas específicas— antes de ejecutarse. El runtime aplica listas de permisos basadas en esas declaraciones.
La comparación de seguridad
| Aspecto | Sistema de plugins | Sistema de traits | |--------|--------------|-------------| | Origen del código | Descargado en tiempo de ejecución | Compilado en tiempo de construcción | | Verificación | Basada en confianza | Verificada por el compilador | | Permisos | En tiempo de ejecución, a menudo sin verificar | Declarados en tipos, aplicados | | Cadena de suministro | Vulnerable | Sin carga de código externo | | Seguridad de tipos | Errores en tiempo de ejecución | Errores en tiempo de compilación |
La idea clave es simple: no puedes tener un ataque a la cadena de suministro si no tienes una cadena de suministro. Las extensiones de ZeroClaw se compilan, no se descargan.
El trade-off real
El enfoque de traits significa que no puedes instalar un nuevo canal descargando un archivo. Añadir una extensión personalizada requiere escribir Rust, añadirlo al código fuente de ZeroClaw y compilar un nuevo binario. Para la mayoría de los usuarios, los 30+ canales y herramientas integrados cubren todo lo que necesitan.
Ese trade-off es intencional. Una superficie de extensión más pequeña y verificada es mejor que una grande y no verificada. ClawHub de OpenClaw demostró lo que pasa cuando optimizas el tamaño del ecosistema sobre la seguridad. ZeroClaw optimiza lo contrario, y el recuento de CVEs refleja esa elección.