PTENES

Guía de Funciones y Arquitecturas

Qué ofrece cada pasillo de la tienda de comestibles de frameworks y cómo funcionan por dentro los 9 principales patrones de arquitectura.

8 Corredores
  1. 1🧬 Identidad y Personalidad
  2. 2🛡 Seguridad y Protección
  3. 3💬 Canales de comunicación
  4. 4🧠 Memoria y Conocimiento
  5. 5⚙ Automatización y programación
  6. 6🔗 Integraciones y Protocolos
  7. 7🧰 Skills y Herramientas Listas
  8. 8🏗 Patrones de arquitectura
9 Arquitecturas
  1. OCOpenClaw — Hub Gateway
  2. ZCZeroClaw — Contratos de Trait
  3. NCNanoClaw — Aislamiento por contenedor
  4. TCTinyClaw — Equipos de Agentes
  5. ICIronClaw — Seguridad Zero-Trust
  6. A0Agent Zero — Bucle de aprendizaje
  7. CCClaudeClaw — Enjambre local + Hive Bus
  8. HMHermes — Bucle reflexivo autocurado
  9. AIAIOS — Agente-como-Proceso-de-SO

Los 8 pasillos de funcionalidades

Cada pasillo agrupa un tipo de capacidad que puedes agregar a tu asistente. Imagínalos como secciones de una tienda de comestibles: eliges los ingredientes que tienen sentido para tu proyecto.

🧬
Identidad y personalidad
Cómo se presenta tu IA

Define quién es tu IA: su tono, sus valores, su forma de hablar y cómo se adapta a diferentes contextos. Sin esto, tienes un chatbot genérico. Con esto, tienes un asistente con voz propia.

Archivo de personalidad Soul.md
Define la personalidad, los valores y el estilo de comunicación en un archivo de texto simple. Cómo escribir una ficha de personaje para tu IA.
Patrón de identidad portátil AIEOS
Formato universal para exportar la personalidad de la IA (psicología, lingüística, motivaciones) a cualquier sistema compatible.
Memoria aislada por grupo
Cada grupo de conversación tiene su propio cerebro. El chat de trabajo y el familiar nunca mezclan el contexto.
Perfiles de agente intercambiables
Personas preconfiguradas (desarrollador, investigador, escritor) entre las que puedes alternar al instante.
Reglas de comportamiento dinámicas
Cambia el comportamiento de la IA a mitad de la conversación, sin reiniciarla. Adaptación inmediata al contexto.
Bots por agente en Telegram ClaudeClaw
Cada agente especialista (comms/content/ops/research) es su propio bot en Telegram, con personalidad, ventana de contexto y avatar propios, y se le pueden delegar tareas mediante @agente: prompt.
Modelado de usuario (Honcho) Hermes
Motor de representaciones del usuario (agente dialéctico) que construye un modelo evolutivo de quién eres en cada conversación; funciona localmente o en la nube.
Agent Hub — Publicar e instalar personas AIOS
El «PyPI de los agentes»: un registry donde se publica un agente con versión (semver) y se instala con 1 comando. La reutilización de personas sale del laboratorio.
Archivos del INTELECTO
intelecto/agent/ ├── context.py ★ Carga workspace/ y arma el system prompt final └── loop.py Reenvía el system prompt al LLM en cada turno workspace/ ├── SOUL.md ★ Personalidad: tono, valores, estilo de respuesta ├── AGENTS.md Reglas de comportamiento y uso de herramientas ├── USER.md Perfil y preferencias del usuario └── MEMORY.md Datos de bootstrap cargados al iniciar
🛡
Seguridad y protección
Protege tus datos y sistemas

Capas de protección entre tu IA y el mundo externo, desde el sandboxing de herramientas hasta la detección de ataques de prompt injection. Esencial en cualquier entorno que acceda a datos sensibles.

Sandbox WASM para herramientas
Las herramientas se ejecutan en contenedores WebAssembly aislados. Físicamente no pueden acceder a tus archivos ni secretos. Más ligeros que Docker.
Aislamiento por contenedor VM
Cada conversación se ejecuta en su propia máquina virtual. La barrera más sólida entre la IA y tu sistema operativo.
Defensa contra la inyección de prompts
Detecta y bloquea intentos de engañar a tu IA con instrucciones ocultas en páginas web o mensajes recibidos.
Detección de filtración de secretos
Verifica las salidas de las herramientas antes de que lleguen a la IA para evitar que se expongan accidentalmente claves de API y contraseñas.
Almacenamiento cifrado de secretos
Claves de API cifradas con ChaCha20 o Fernet. Aunque roben el archivo, no podrán leerlas.
Controles de aprobación de ejecución
Tres niveles de control: solo lectura, supervisado (pide permiso) y autonomía total. Tú decides cuánto confiar.
Lista de bloqueo de comandos peligrosos
Bloquea automáticamente comandos destructivos (borrar todo, formatear discos, reiniciar) mediante coincidencia de subcadenas.
Protección contra la exfiltración de datos ClaudeClaw
Revisa todas las respuestas salientes con regex (claves de API, tokens de Slack/GitHub, AWS, cadenas hexadecimales largas) y oculta los secretos antes de enviarlas al chat: una barrera contra filtraciones por prompt injection.
Interruptores de apagado con recarga en caliente ClaudeClaw
Las flags de .env se vuelven a leer cada ~1,5s: desactiva el spawn de LLM, las mutaciones del dashboard, el scheduler o War Room en menos de 2s, sin reiniciar el proceso y con un contador de rechazos.
Allowlist de salida + fortalecimiento del sandbox Hermes
Sandbox de ejecución (firejail/bubblewrap/docker), allowlist de egress y audit log inmutable; blacklist de ~/.ssh y ~/.aws para contener la exfiltración.
Defensa contra la inyección de prompts (OWASP #1) Hermes
Tratamiento del OWASP #1 de LLM Apps: separa los datos de las instrucciones al leer contenido web o de terceros, con un modelo de amenazas que identifica a 4 atacantes.
Archivos del INTELECTO
intelecto/security/ ├── secrets.py ★ Fernet + PBKDF2: cifra claves con el UUID del hardware └── safety.py Blocklist de comandos + path traversal + registro de auditoría intelecto/tools/ └── shell.py run_command con timeout de 60s y blocklist integrada ~/.intelecto/ ├── .secrets Claves cifradas (inútiles en otro hardware) └── audit.log Registro de todos los comandos ejecutados
💬
Canales de comunicación
Dónde vive tu IA

El canal es la «puerta de entrada» de tu IA. Define en qué aplicación interactuará el usuario con ella. Cada canal tiene características distintas: elige dónde ya está tu público.

WhatsApp
El más natural para el uso empresarial diario en Brasil. Compatible con texto, imágenes y notas de voz.
Telegram
Configuración más sencilla (solo un token). Contenido multimedia, botones inline y uso compartido de archivos. Ideal para equipos técnicos.
Discord
Ideal para gestionar comunidades y canales de equipo. Compatible con comandos slash.
Slack
Integración sin IP pública mediante Socket Mode. Ideal para automatizar procesos internos.
Correo electrónico (IMAP/SMTP)
La IA lee tu correo y puede responder. Filtra el spam, resume boletines y redacta respuestas.
Panel web
Interfaz en el navegador con estado en tiempo real, memoria visible y progreso de tareas.
Palabra de activación por voz
Di «hey claude» y tu IA te escucha. Control por voz siempre activo, como un altavoz inteligente privado.
Avatar en reunión de video en vivo ClaudeClaw
Envía un agente a una videollamada real (Daily.co/Meet/Zoom) como participante con un avatar Pika que habla en tiempo real.
War Room con voz en vivo ClaudeClaw
Sala de reuniones con tu equipo de agentes mediante voz en vivo a través de Gemini Live, cada agente con su propia voz, en menos de un segundo, sin Deepgram ni Cartesia.
Gateway de mensajería unificado Hermes
Un gateway normaliza CLI, Discord, Slack, WhatsApp, HTTP y cron en el mismo objeto Message: un cerebro, todas las bocas, un agente independiente del canal.
Archivos del INTELECTO
intelecto/channels/ ├── base.py ★ Contrato abstracto: start(on_message), send(), stop() └── telegram.py Long-polling, división en >4096 caracteres, indicador de escritura # Para agregar canales nuevos — implementa BaseChannel: channels/whatsapp.py WhatsApp (sin tocar el código del agente) channels/discord.py Discord (mismo contrato) channels/slack.py Slack Socket Mode
🧠
Memoria y conocimiento
Cómo recuerda tu IA

La diferencia entre una IA que lo olvida todo al reiniciarse y una que te conoce desde hace meses. La elección del sistema de memoria define el costo, la precisión y la capacidad de recuperación a largo plazo.

Búsqueda híbrida vectorial + por palabras clave
Combina comprensión semántica (lo que quieres decir) con búsqueda exacta (palabras específicas). Es la opción más precisa, pero tiene un costo de embedding.
SQLite FTS5 (Búsqueda por palabras clave)
Búsqueda de texto completo con clasificación BM25. Costo cero de API, sin modelos de embeddings. Cubre el 90% de las necesidades de recall.
Sistema de Memoria de Dos Capas
Capa 1: datos rápidos en MEMORY.md. Capa 2: registro del historial con búsqueda. Simple y eficaz para proyectos pequeños.
Memoria de soluciones
La IA guarda automáticamente las soluciones que funcionan. La próxima vez que enfrentes un problema similar, recuerda qué funcionó.
Base de conocimiento en documentos
Sube PDFs, hojas de cálculo y documentos. La IA investiga y analiza. El conocimiento de tu empresa al alcance del chat.
Compactación automática de sesiones
Cuando las conversaciones se alargan demasiado, resume automáticamente las partes antiguas para mantener la IA rápida.
Memoria de 5 capas con decaimiento ClaudeClaw
Memoria que extrae hechos mediante Gemini (puntuación de importancia), guarda embeddings vectoriales, busca en 5 frentes, consolida patrones cada 30min y pierde o gana relevancia según el uso.
Higiene y uso compartido de la memoria ClaudeClaw
Revisión periódica que propone (nunca escribe por sí sola) qué fijar, qué conflictos resolver y qué duplicados combinar, además de la promoción selectiva de hechos universales al nivel compartido entre agentes.
Curación de memoria en el paso Reflect Hermes
Bucle perceive→act→reflect→save: un modelo económico (<1k tokens) decide qué vale la pena recordar y cura la memoria por sí solo, en lugar de que tú tengas que indicárselo todo.
Sistema de Archivos Semántico (LSFS) AIOS
Almacenamiento que indexa mediante embeddings: encuentras el archivo por su significado en lenguaje natural ("el PDF sobre AIOS de la semana pasada"), no por la ruta. Paper ICLR 2025; complementa el FS, no lo reemplaza.
Memoria agéntica curada (A-MEM) AIOS
Memoria en la que el propio agente decide qué guardar, comprime lo redundante e indexa lo que se puede buscar: combate la sobrecarga de contexto de los agentes de larga duración.
Archivos del INTELECTO
intelecto/memory/ └── store.py ★ SQLite FTS5 + BM25 + deduplicación automática (>80% = actualiza) intelecto/agent/ └── context.py memory.search(query) → inyecta resultados en el system prompt ~/.intelecto/ └── memory.db Base de datos persistente — sobrevive a los reinicios # Categorías almacenadas: fact · hechos sobre ti y preferencias conversation · resúmenes de conversaciones importantes solución · soluciones para problemas recurrentes
⚙
Automatización y programación
Trabaja mientras duermes

Transforma tu IA de reactiva a proactiva. En vez de esperar a que preguntes algo, ejecuta tareas en horarios definidos, monitorea eventos y trabaja en segundo plano.

Programación Cron
"Todos los lunes a las 9 h, envíame un resumen del día." Funciona como un despertador confiable para tareas recurrentes.
Heartbeat (comprobaciones periódicas)
La IA se activa cada 30 minutos para comprobar si algo requiere atención. Proactiva, no solo reactiva.
Automatización del navegador
Controla un navegador real: completa formularios, hace clic en botones, extrae datos y toma capturas de pantalla. Automatiza tareas repetitivas en la web.
Activadores vía webhook
Servicios externos (Zapier, n8n, Shopify) activan tu IA mediante una URL. Se conecta a cualquier ecosistema de automatización existente.
Subagentes en Segundo Plano
IA auxiliar para tareas largas. El agente principal sigue respondiendo mientras los trabajadores hacen el trabajo pesado.
Colaboración en equipo de agentes
Varios agentes especializados (@coder, @reviewer, @writer) se pasan el trabajo automáticamente.
Tablero Kanban de Mission Control ClaudeClaw
Tablero kanban con una columna por agente, asignación automática de tareas por Gemini, arrastrar y soltar para reasignar y panel lateral con el historial de todo lo que se completó.
Verificaciones de aceptación en tareas programadas ClaudeClaw
Una tarea programada solo cuenta como éxito si la salida contiene un marcador definido: un "turno completado" deja de confundirse con un "objetivo cumplido".
Agente proactivo mediante heartbeat Hermes
Scheduler integrado (APScheduler) con detección de zombies, reclaim y reintentos: informes, recordatorios y check-ins proactivos que hacen que el agente parezca activo 24/7.
Función objetivo Northstar Hermes
En lugar de pregunta→respuesta, le das una meta y el agente consume un presupuesto de turnos (~20) o genera 4-10 acciones con una barra de progreso hasta alcanzar el objetivo.
Programación de agentes como procesos (FIFO/Round-Robin) AIOS
Varios agentes LLM se convierten en procesos programados por un Scheduler con fairness: en lugar de que un agente de larga duración bloquee a todos, el kernel reparte el acceso al LLM (FIFO para 1-2 agentes, Round-Robin para 3+).
Archivos del INTELECTO — Roadmap Phase 2
intelecto/tools/ # planificado — no implementado en el v0.1 ├── cron.py Programación: "todos los lunes a las 9 h, envíame..." └── web.py Búsqueda web y fetch de páginas/URLs intelecto/agent/ └── loop.py Ya admite múltiples rondas: base para la automatización # Implementado hoy: com.intelecto.agent.plist Reinicio automático mediante macOS launchd (activo ahora) start.sh Launcher con venv + instalación automática
🔗
Integraciones y protocolos
Conexión con el mundo

Cómo se conecta tu IA con proveedores de modelos, servicios externos y protocolos estándar. Aquí se toman las decisiones sobre costo, privacidad y escalabilidad de los modelos de IA.

OpenRouter — 100+ modelos, 1 clave
Accede a Claude, GPT-4, Gemini, Mistral, DeepSeek, Llama y más de 100 modelos con una sola clave de API. Cambia de modelo sin modificar el código.
Soporte para LLM Local (Ollama)
Ejecuta modelos en tu propia computadora. Costo cero de API, privacidad total, sin internet. Úsalo junto con OpenRouter: nube para potencia, local para privacidad.
Conmutación por error entre varios proveedores
Si Claude falla, cambia automáticamente a GPT o Gemini. Con OpenRouter tienes más de 100 modelos como alternativas en una sola clave.
Selección de modelo por tarea
Claude Sonnet para razonamiento complejo, Haiku para respuestas rápidas y económicas, DeepSeek R1 para código. Control total del costo y la calidad.
MCP (Model Context Protocol)
Estándar universal para conectar la IA con herramientas externas. Un protocolo, miles de integraciones: el «USB» de las herramientas de IA.
Proveedores de medios especializados (fal.ai, Kie.ai)
Para imágenes, sonido y video, usa proveedores especializados. Los LLM de texto son débiles en medios: fal.ai y Kie.ai son la opción adecuada para crear contenido.
Sistema de Skills / Plugins
Instala nuevas capacidades como aplicaciones en tu celular. No necesitas programar para agregar integraciones prediseñadas.
Control de hardware / IoT
Controla dispositivos físicos mediante pines GPIO, I2C y SPI. La IA puede interactuar con el mundo real en proyectos integrados.
Motor de proveedores normalizado (ACP) ClaudeClaw
Capa de engine única con adapters para Claude SDK, OpenRouter nativo y ACP (OpenCode/Gemini CLI/Codex/custom), con sesiones separadas por provider para no cruzar el historial.
Monitor del estado de OAuth ClaudeClaw
Te avisa por Telegram antes de que expire el token OAuth de Claude — esencial en un deploy daemon (launchd/systemd), donde la expiración provoca una falla silenciosa.
Enrutamiento Multi-Brain por Rol Hermes
Enrutamiento de modelos por rol en la configuración (main/reflect/routing/fallbacks) y por subtarea dentro de la skill: un modelo potente para el trabajo, uno económico para la clasificación inicial.
Crea tu propio MCP Server Hermes
Crea tu propio servidor MCP en Python (FastMCP) o Node (@modelcontextprotocol/sdk) con autenticación OAuth/JWT y publícalo mediante Docker/npm/pip.
Capa adaptadora de frameworks AIOS
Capa de ejecución debajo de los frameworks: reemplaza la llamada directa al LLM por una syscall (patrón adapter) y LangChain/AutoGen/CrewAI/MetaGPT/OpenAGI heredan scheduling, fairness y persistencia — migración incremental.
Archivos del INTELECTO
intelecto/providers/ ├── base.py ★ Contrato abstracto: async chat() → LLMResponse ├── openrouter.py OpenRouter vía LiteLLM (100+ modelos con 1 clave) └── ollama.py Ollama local (costo cero, sin cloud) intelecto/ └── config.py Configura el provider predeterminado y el modelo para cada tarea requirements.txt └── litellm ≥1.40.0 Interfaz unificada: OpenRouter, Ollama, cualquier LLM # Agregar un proveedor = implementar BaseProvider: providers/gemini.py · providers/groq.py · providers/cohere.py
🧰
Skills Integradas y Herramientas Listas
Lo que viene listo en la caja

El corredor más extenso: son las capacidades concretas que tu IA puede ejecutar hoy, sin implementarlas desde cero. Abarca productividad, comunicación, hogar inteligente, desarrollo y mucho más.

Suite Google Workspace
Gmail, Calendar, Drive, Sheets, Docs y Slides. Integración completa con Google: envía correos, crea hojas de cálculo y gestiona el calendario.
GitHub (Issues, PRs, CI, API)
Flujo completo: gestiona issues, revisa pull requests y activa CI. Gestión de código por chat.
Notion, Obsidian, Apple Notes, Bear
Integraciones con las principales aplicaciones de notas. Crea, edita y busca notas directamente desde el asistente.
Whisper Speech-to-Text + ElevenLabs TTS
Convierte voz en texto y texto en voz natural. Funciona localmente (sin API) o en la nube.
Generación de imágenes con IA
Genera imágenes mediante la API de OpenAI, Gemini o proveedores especializados como fal.ai. Compatible con inpainting y generación por lotes.
Resumidor de URL / Video / Podcast
Resume páginas web, videos de YouTube y podcasts. Obtén lo esencial sin leer ni ver todo.
Control del hogar inteligente (Philips Hue, Sonos)
Controla luces, altavoces y dispositivos inteligentes mediante comandos en lenguaje natural.
Orquestación de agentes de codificación
Ejecuta Codex CLI, Claude Code u otros agentes de codificación de forma programática. IA que gestiona otras IA.
Composio (1000+ aplicaciones)
Acceso OAuth con un clic a más de 1000 apps: Gmail, Notion, GitHub, Slack y mucho más mediante Composio.
Generación autónoma de skills Hermes
El agente detecta un workflow repetido (≥3x) en el paso reflect y escribe por sí mismo una SKILL.md en borrador para que la apruebes: habilidades que surgen del uso, sin programar.
Skills Portátiles agentskills.io Hermes
Skills como carpeta autocontenida con SKILL.md (frontmatter YAML + markdown), estándar abierto portable entre Hermes, Claude Code y Codex.
Acciones de uso de la computadora Hermes
Acciones reales en la PC: visión del navegador con Chrome DevTools, lectura visual de la pantalla y movimientos reales del cursor — habilitables en las tools, con responsabilidad.
Comandos de Skill registrados automáticamente ClaudeClaw
Cualquier skill con user_invocable:true se convierte automáticamente en un /comando en el menú de Telegram (setMyCommands), sin tocar código: solo suelta la carpeta de la skill.
Uso del computador mediante VM + MCP (LiteCUA) AIOS
Expone toda la computadora como herramientas MCP (screenshot/click/type) dentro de una VM sandbox (KVM/Firecracker). Bucle percibir-decidir-actuar con LLM multimodal para operar interfaces gráficas sin API.
Archivos del INTELECTO
intelecto/tools/ ├── base.py ★ Contrato: name, description, parameters, execute() ├── registry.py Descubrimiento y dispatch de herramientas ├── filesystem.py read_file, write_file, list_directory └── shell.py run_command con comprobación de seguridad y timeout de 60s # Agregar una skill = crear un archivo nuevo que herede de BaseTool: tools/github.py · tools/notion.py · tools/calendar.py # Sin tocar registry.py — descubrimiento automático
🏗
Patrones de arquitectura
Cómo estructurar tu framework

Los patrones estructurales que definen cómo se conectan los componentes de tu asistente. La elección aquí afecta la facilidad de mantenimiento, la escalabilidad y la facilidad de ampliación.

Modularidad mediante Traits / clases abstractas
Cada componente se define mediante un contrato (interfaz). Cambia las implementaciones sin tocar el código del agente.
Gateway WebSocket
Servidor central al que se conectan todos los canales. El patrón de «torre de control»: máximo control, mayor complejidad.
Arquitectura de bus de mensajes
Los canales y los agentes se comunican mediante una cola central. Separación clara y fácil de ampliar con nuevos canales.
Cola de mensajes basada en archivos
Mensajes almacenados como archivos en directorios (incoming → processing → outgoing). Simple, confiable, sin base de datos.
Implementación con binario único
Un archivo ejecutable, sin dependencias. Cópialo en cualquier lugar y funciona. La historia de implementación más simple posible.
Aislamiento del espacio de trabajo por proyecto
Espacios separados por cliente o proyecto, cada uno con su propia memoria y secretos. Sin mezclar datos.
Bus de cerebro compartido (Hive Bus) ClaudeClaw
Bus de eventos (tabla hive_mind) en el que todos los agentes escriben y que todos leen: todo el equipo ve lo que cada agente hizo en las últimas 24h dentro del contexto de memoria. ver arquitectura →
Bucle reflexivo autoevolutivo Hermes
Bucle perceive→act→reflect→save en el que el agente cura su propia memoria y genera sus propias habilidades a medida que lo usas, en lugar de usar un canal, un bucle y una memoria estáticos. ver arquitectura →
Agente-como-Proceso-de-SO (Kernel LLM) AIOS
La LLM se convierte en el núcleo de un kernel y cada agente es un proceso planificado, con syscalls auditables y cambio de contexto — frameworks como LangChain/AutoGen/CrewAI se ejecutan encima. ver arquitectura →
Archivos del INTELECTO
intelecto/ ├── main.py ★ Punto de entrada: detecta la configuración e inicia el bot └── config.py Singleton de configuración (~/.intelecto/config.json) intelecto/agent/ ├── loop.py Core: recibe → piensa → responde (máx. 5 rondas) └── context.py Arma el system prompt + memorias relevantes # Contratos — cada subsistema implementa su interfaz: providers/base.py async chat() → LLMResponse channels/base.py start(), send(), stop() memory/store.py save(), search(), forget(), recent() tools/base.py name, description, execute()

Las 9 arquitecturas en detalle

Cómo organiza internamente sus componentes cada framework. Estos son los planos que seguirías al construir con cada enfoque.

OC
OpenClaw — Hub Gateway
TypeScript · La arquitectura de "torre de control"

OpenClaw usa un servidor WebSocket central (Gateway) como único punto de entrada para todos los canales. Los mensajes de WhatsApp, Telegram, Slack, iMessage y voz pasan por el mismo hub antes de llegar al agente. Esto garantiza un control centralizado de las sesiones, el enrutamiento entre varios agentes y la compatibilidad unificada con canvas visual y voz.

CHANNELS AGENTS WhatsApp Telegram Slack Agent A Agent B Discord iMessage WebChat (Work) (Personal) \ | / \ / \ | / \ / v v v v v +------------------+ +------------------+ | GATEWAY |------| SESSION STORE | | (WebSocket Hub) | | (JSONL files) | +------------------+ +------------------+ | +--------+--------+ | | | TOOLS CANVAS VOICE Browser Live UI Wake Word Files Diagrams TTS/STT Shell React ElevenLabs
Punto fuerte
Máximo control y visibilidad. Todo pasa por el hub: los registros, el enrutamiento y las sesiones están en un solo lugar.
Complejidad
El Gateway es el único punto de falla. Es más difícil de probar y de escalar horizontalmente.
Ideal para
Proyectos que necesitan varios canales, varios agentes e interfaz visual al mismo tiempo.
Estructura de archivos
src/gateway/server/ ├── server.ts ★ Servidor central de WebSocket: punto único de entrada ├── server-channels.ts Conecta y gestiona todos los canales en el gateway ├── server-chat.ts Sesiones de chat, historial y streaming ├── server-cron.ts Tareas programadas integradas en el gateway ├── server-startup.ts Arranque, comprobaciones de estado y recuperación automática └── ws-connection/ Gestión de conexiones WebSocket individuales src/channels/registry.ts Descubre y registra los canales disponibles src/sessions/ Sesiones almacenadas en JSONL por agente src/agents/pi-embedded-runner.ts Runner: recibe → piensa → responde src/gateway/protocol/ Protocolo de mensajes del gateway
ZC
ZeroClaw — Contratos de Trait (Rust)
Rust · La arquitectura «LEGO de componentes»

Cada subsistema (proveedor de IA, canal, memoria) se define mediante un trait: un contrato que dice «cualquier implementación debe tener estos métodos». El archivo config.toml decide qué implementaciones usar en runtime. Puedes cambiar el proveedor de IA de Claude a Ollama, o el canal de Telegram a WhatsApp, sin tocar el código del agente. El resultado es una huella de memoria inferior a 5MB y un arranque en 10ms.

config.toml define qué implementaciones usar: +-----------+ +-----------+ +----------+ | Provider | | Channel | | Memory | | (trait) | | (trait) | | (trait) | +-----------+ +-----------+ +----------+ ^ ^ ^ | | | +----+----+ +-----+-----+ +----+----+ |OpenAI | |Telegram | |SQLite | |Claude | |Discord | |Markdown | |Ollama | |Slack | |None | |Gemini | |WhatsApp | +---------+ |22 more..| |Email | +---------+ |Webhook | +-----------+ Cambia CUALQUIER pieza sin tocar el código del agente
Punto fuerte
Máxima modularidad y eficiencia. Cada componente se puede probar de forma independiente. Funciona en hardware de $10.
Complejidad
Rust tiene una curva de aprendizaje alta. El sistema de traits puede intimidar a quienes vienen de lenguajes dinámicos.
Ideal para
Proyectos que requieren una eficiencia extrema, hardware limitado o cambios frecuentes de proveedores de IA.
Estructura de archivos — codebase Rust separado
src/ ├── main.rs ★ Punto de entrada y CLI └── config.rs Carga config.toml e instancia implementaciones traits/ ├── provider.rs ★ Trait Provider: async chat() → LLMResponse ├── channel.rs Trait Channel: start(), send(), stop() └── memory.rs Trait Memory: save(), search(), forget() providers/ Implementaciones intercambiables de Provider: ├── openai.rs claude.rs Proveedores de nube (OpenAI, Anthropic) └── ollama.rs Modelo local (costo cero, sin cloud) channels/ Implementaciones intercambiables de Channel: └── telegram.rs discord.rs Cambia de canal sin modificar el agente
NC
NanoClaw — Aislamiento por contenedor
TypeScript · La arquitectura de "cerebros separados"

NanoClaw resuelve un problema específico de WhatsApp para empresas: ¿cómo garantizar que el contexto de un grupo de trabajo nunca se filtre al grupo familiar? La respuesta es radical: cada conversación se ejecuta en su propio contenedor aislado, con su propio archivo CLAUDE.md y un sistema de archivos separado. El host gestiona la conexión de WhatsApp y envía los mensajes al contenedor correspondiente.

HOST (macOS/Linux) +--------------------------------------------+ | WhatsApp Connection (Baileys) | | SQLite Message Store | | Message Polling Loop | | Task Scheduler | +--------------------------------------------+ | | | +-- Container --+ +-- Container --+ +-- Container --+ | Work Group | | Family Group | | Admin Chat | | Claude SDK | | Claude SDK | | Claude SDK | | Own CLAUDE.md | | Own CLAUDE.md | | Full access | | Sandboxed FS | | Sandboxed FS | | All groups | +---------------+ +---------------+ +--------------+ Cada grupo = cerebro aislado. No se ven entre sí.
Punto fuerte
Aislamiento total entre contextos. Ideal para uso empresarial, donde los datos de distintos clientes no se pueden mezclar.
Complejidad
Sobrecarga de contenedores por grupo. No es lo mejor para un asistente personal de un solo usuario.
Ideal para
Empresas con varios grupos de WhatsApp que necesitan contextos totalmente separados.
Estructura de archivos — base de código de NanoClaw
src/ ├── host.ts ★ Host: gestiona la conexión de WhatsApp (Baileys) ├── message-store.ts SQLite: cola de mensajes por grupo └── scheduler.ts Enruta el mensaje al contenedor correcto containers/ ├── manager.ts ★ Crea y destruye contenedores por grupo ├── dispatch.ts Enruta mensajes al contenedor correcto └── sandbox-fs.ts Sistema de archivos aislado por contenedor agent-container/ ├── runner.ts Ejecuta Claude SDK dentro del contenedor └── claude-md.ts Carga el CLAUDE.md específico del grupo
TC
TinyClaw — Equipos de Agentes
TypeScript · La arquitectura de "pequeña empresa de IA"

TinyClaw trata a cada agente como un colaborador especializado de un equipo. Los mensajes entran en una cola basada en archivos (sin base de datos) y cada agente los toma de su propia bandeja de entrada. Un agente puede mencionar a otro (@reviewer, @writer) para pasarle el trabajo. Procesamiento paralelo: mientras @coder escribe código, @reviewer puede estar analizando otro PR.

TÚ (vía Discord / Telegram / WhatsApp) | v +------------------+ | Message Queue | incoming/ -> processing/ -> outgoing/ | (File-Based) | Cada agente toma los mensajes de su propia bandeja de entrada +------------------+ | +----+----+----+----+ | | | @coder @reviewer @writer Claude OpenAI Claude Opus GPT-5 Sonnet | ^ ^ | | | +---mención----------+ Los agentes se pasan el trabajo entre sí "[@reviewer: revisa este código]" Procesamiento paralelo. Secuencial por agente.
Punto fuerte
Cada agente usa el modelo más adecuado para su especialidad. Procesamiento paralelo de tareas complejas.
Complejidad
La coordinación entre agentes puede crear dependencias circulares. Depurar flujos multiagente requiere más trabajo.
Ideal para
Pipelines de desarrollo de software donde la revisión, la escritura y la programación se realizan en paralelo.
Estructura de archivos — OpenClaw (subagentes)
src/agents/ ├── subagent-registry.ts ★ Registro y coordinación de subagentes activos ├── openclaw-tools.ts Herramientas: spawn, sesiones paralelas, estado ├── subagent-announce.ts Notificaciones de @mentions entre agentes └── subagent-announce-queue.ts Cola de mensajes entre agentes src/cron/isolated-agent/ Ejecuta agentes en un contexto totalmente aislado src/agents/lanes.ts Control del paralelismo entre agentes Cola basada en archivos (sin base de datos): incoming/ → processing/ → outgoing/ Cada agente lee su propia bandeja de entrada desde el disco
IC
IronClaw — Seguridad Zero-Trust
TypeScript · La arquitectura de "fortaleza en capas"

IronClaw parte del principio de que ninguna entrada es confiable: ni los mensajes del usuario, ni los resultados de las herramientas, ni las salidas del LLM. Cada etapa del pipeline tiene su propia capa de seguridad: detección de prompt injection en la entrada, WASM sandbox para aislar herramientas y detector de filtraciones de secretos en la salida. El Job Scheduler permite hasta 5 ejecuciones paralelas con control de rate limiting.

Entran mensajes Capas de seguridad CLI Slack Telegram | | v +----v----+ +--------------------+ | Channel | | Prompt Injection | | Manager |--->| Pattern Detection | +---------+ +--------------------+ | | +----v----+ +--------------------+ | Job | | WASM Sandbox | | Scheduler--->| Capability Allowlist| | (5x //) | | Rate Limiting | | | | Credential Inject | +---------+ +--------------------+ | | +----v----+ +--------------------+ | LLM | | Leak Detector | | NEAR AI | | Analiza salidas | | +Ollama | | en busca de secretos| +---------+ +--------------------+
Punto fuerte
La arquitectura más segura disponible. Ideal para entornos corporativos o donde la IA accede a datos sensibles.
Complejidad
Cada capa agrega latencia. Configurar las allowlists de herramientas requiere una planificación cuidadosa.
Ideal para
Empresas con requisitos de compliance, datos de clientes o donde un comando incorrecto puede causar daños reales.
Estructura de archivos — OpenClaw (capas de seguridad)
src/security/ ├── audit.ts ★ Registro de auditoría completo de todas las acciones del agente ├── audit-fs.ts Monitoreo y registro de operaciones del filesystem └── external-content.ts Detección de inyección de prompts en entradas externas src/agents/ ├── sandbox/sandbox.ts Sandbox WASM: aísla completamente las herramientas ├── tool-policy.ts Controles de aprobación: 3 niveles de confianza ├── pi-tools.policy.ts Allowlist explícita de herramientas permitidas └── bash-tools.ts Blocklist de comandos peligrosos (rm -rf, etc.) src/channels/allowlists/ Allowlist de usuarios por canal src/agents/context-window-guard.ts Protección contra el desbordamiento del contexto
A0
Agent Zero — Bucle de aprendizaje
Python · La arquitectura «IA que aprende haciendo»

Agent Zero se construye en torno a un ciclo de mejora continua: antes de resolver un problema, consulta la memoria («¿ya resolví esto antes?»). Cuando lo resuelve, guarda la solución para usarla en el futuro. Para tareas complejas, delega en subagentes especializados en investigación o código. Con el tiempo, se vuelve cada vez más eficiente en las tareas que más usas y puede reescribir sus propias reglas de comportamiento en medio de una conversación.

Haces una pregunta | v +-----------+ +-----------+ | Agent 0 |---->| Memory | | (Main) |<----| Search | "¿Ya resolví esto antes?" +-----------+ +-----------+ | +----+----+ | | Sub-Agent Sub-Agent Delegación para (Research) (Code) tareas complejas | | +----+----+ | +----v----+ +-----------+ | ¡Solución |---->| Memory | | encontrada! | | GUARDAR | "Recordar para la próxima" +---------+ +-----------+ Se vuelve más inteligente con cada interacción
Punto fuerte
Aprende con el uso. El paradigma «computadora como herramienta» le permite resolver problemas que las herramientas preconstruidas no cubren.
Complejidad
Comportamiento menos predecible: la IA puede tomar caminos inesperados. Requiere más supervisión inicial.
Ideal para
Investigación, análisis exploratorio y tareas abiertas en las que la flexibilidad importa más que la previsibilidad.
Estructura de archivos — codebase Python separado
agent_zero/ ├── agent.py ★ Bucle principal: pregunta → memoria → resuelve → guarda ├── memory.py Busca y almacena soluciones de sesiones anteriores └── context.py Arma el system prompt con memorias relevantes tools/ ├── web_search.py Búsqueda web para investigación exploratoria ├── code_exec.py Ejecución de código en sandbox └── file_ops.py Operaciones de archivos y filesystem workspace/ ├── memory.json Soluciones guardadas de sesiones anteriores └── prompts/ Plantillas de prompts por tipo de tarea Flujo: pregunta → busca en la memoria → subagente → solución → guarda
CC
ClaudeClaw — Enjambre local multiagente + Hive Bus
TypeScript/Node.js · La arquitectura de "cuartel general de bolsillo"

En lugar del loop de un solo agente (Telegram→loop→tool→memoria), ClaudeClaw ejecuta N agentes especialistas como bots independientes en la MISMA máquina y DB. Delegan entre sí (@agente), se reúnen en tiempo real (War Room de texto/voz) y publican cada acción en un bus de eventos compartido (tabla hive_mind), que funciona como memoria del equipo Y como visualización: un cerebro anatómico 3D. Esto se complementa con un plan de contención operativa: kill switches con hot-reload + tool-policy que deniega por defecto + protección contra la exfiltración forman una malla de seguridad en tiempo de ejecución sobre la ejecución con acceso completo.

TÚ (Telegram · Dashboard · War Room · Mission Control) | +----+----+----+----+ delegación @agente: | | | | | <----------------------+ @comms @content @ops @research | bot bot bot bot (cada uno = bot propio, voz propia) | | | | | +--+--+--------+--+--+--------------------------+ | | v v +------------------+ +------------------+ | HIVE BUS |----->| Cerebro 3D | | (tabla hive_mind)| | Three.js/WebGL | | toda acción = evento| | lobos/sinapsis | +------------------+ +------------------+ | +--+-------------------------------+ | CONTENCIÓN OPERATIVA (runtime) | | Kill switches (hot-reload ~1.5s)| | Tool policy default-deny | | Outbound exfiltration guard | +----------------------------------+
Punto fuerte
Un equipo de agentes que conversa de verdad: delegación, War Room en vivo y un cerebro compartido visible. La memoria del equipo se convierte en observabilidad.
Complejidad
Muchas interfaces y procesos que mantener. La ejecución con acceso total exige que la red de contención (kill switches, default-deny, leak guard) esté siempre activa.
Ideal para
Quien quiera orquestar localmente un equipo de agentes especialistas, con reuniones en vivo y visibilidad total de lo que hizo cada uno.
Estructura de archivos — base de código de ClaudeClaw OS
src/agents/ ├── registry.ts ★ Un bot por agente especialista (comms/content/ops/research) ├── delegate.ts Delegación @agente: entre bots independientes └── war-room.ts Sala en vivo: /standup, /discuss, voz de Gemini Live src/hive/ ├── hive-mind.ts ★ Bus de eventos: tabla hive_mind (todos escriben y leen) └── brain-3d/ Cerebro anatómico 3D (Three.js + UnrealBloom) src/security/ ├── kill-switches.ts Las flags de .env se vuelven a leer cada ~1.5s (se desactiva en <2s) ├── tool-policy.ts Denegar por defecto: efectos secundarios solo mediante opt-in en agent.yaml └── exfiltration-guard.ts Elimina los secretos con regex antes de enviar
HM
Hermes — Bucle reflexivo + memoria autocurada + habilidades autónomas
Python · La arquitectura «agente que se mejora a sí mismo»

Hermes es un ciclo perceive→act→reflect→save. Un gateway único normaliza cualquier canal (CLI, Discord, Slack, WhatsApp, HTTP, cron) en un objeto Message. El paso reflect usa un modelo económico para depurar la memoria (SQLite FTS5/BM25 local, en 3 capas) y detectar workflows repetidos; esos patrones se convierten en skills generadas automáticamente (SKILL.md con el estándar agentskills.io) que el agente empieza a reutilizar. Todo es independiente del modelo (enrutamiento por rol) y proactivo mediante heartbeat/cron. Es el contrapunto a los frameworks que separan el canal, el ciclo y la memoria de forma estática: aquí el agente mejora su propia memoria y sus propias habilidades con el uso.

CLI Discord Slack WhatsApp HTTP cron \ | | | | / v v v v v v +------------------------------------------+ | UNIFIED GATEWAY → objeto Message | +------------------------------------------+ | +------------v------------+ | LOOP REFLEXIVO | | perceive → act | | ↓ | | reflect (modelo barato) |----+ detecta workflow repetido (≥3x) | ↓ | | | save | v +------------+-------------+ +------------------+ | | SKILL.md gerada | +------------v------------+ | (agentskills.io) | | MEMÓRIA 3 CAMADAS | +------------------+ | SQLite FTS5 / BM25 | reutilizada no act | conversas·fatos·skills | +-------------------------+
Punto fuerte
El agente se mejora por sí solo: depura la memoria con un modelo económico y escribe sus propias skills a partir del uso. Un cerebro, todos los canales.
Complejidad
El paso reflect y la generación de skills agregan etapas y costos. Las skills generadas automáticamente requieren aprobación para evitar que el comportamiento se desvíe.
Ideal para
Asistente personal de uso continuo y multicanal, que debe volverse más eficiente en las tareas recurrentes sin que tengas que programar cada una.
Estructura de archivos — base de código de Hermes
hermes/ ├── gateway.py ★ Normaliza todos los canales en un objeto Message ├── loop.py ★ perceive → act → reflect → save └── reflect.py Un modelo económico cura la memoria y detecta workflows hermes/memory/ └── store.py SQLite FTS5/BM25 — 3 capas (conversaciones·hechos·skills) hermes/skills/ ├── generator.py Escribe SKILL.md como borrador a partir del uso (≥3x) └── <skill>/SKILL.md Carpeta autocontenida y portátil (agentskills.io) config.yaml Proveedor, modelos por función, conjuntos de herramientas, canales, cron
AI
AIOS — Agente-como-Proceso-de-SO / Kernel LLM
Python · La arquitectura «sistema operativo de agentes»

AIOS integra el LLM como núcleo de un kernel y trata cada agente LLM como un PROCESO del sistema operativo. Varios agentes coexisten y comparten modelos, memoria y herramientas; el Scheduler (FIFO/Round-Robin) decide quién llama al LLM, el Context Manager toma snapshots y restaura agentes para pausarlos y reanudarlos, y todo fluye mediante syscalls auditables. El agente se comunica con el kernel mediante el SDK Cerebrum (repo separado), en modo Local o Remote. Frameworks como LangChain, AutoGen y CrewAI se ejecutan SOBRE él mediante un adapter.

APPLICATION Agente A Agente B Agente C (procesos) LangChain AutoGen CrewAI se ejecutan encima | | | | v v v v +------------------------------------------------+ | CEREBRUM SDK (wrappers de syscall) | | Agent base · @tool · hub client · Local/Remote | +------------------------------------------------+ | syscalls (LLMCall, Mem R/W, | ToolCall, ContextSwitch) v +------------------------------------------------+ | AIOS KERNEL | | llm_core · memory_manager · storage_manager | | tool_manager · scheduler · context_manager | +------------------------------------------------+ | v OS · Proveedores (OpenRouter/Ollama/...) aios-rs/ reescritura experimental del kernel en Rust
Punto fuerte
Único modelo que escala agentes como procesos: fairness multiagente, preempción y recursos compartidos de verdad. Los frameworks existentes se ejecutan por debajo mediante un adapter.
Complejidad
Más pesado y exigente desde el punto de vista conceptual (hay que pensar en syscalls y scheduling); excesivo para un solo agente o asistente personal: destaca en entornos multiagente concurrentes.
Ideal para
Operar múltiples agentes concurrentes a escala, realizar investigaciones de larga duración con checkpoints y contar con infraestructura compartida donde la equidad y el aislamiento entre agentes son importantes.
Estructura de archivos — kernel + SDK (repos que reflejan Linux × glibc)
aios/kernel/ ├── llm_core.py ★ La LLM integrada como núcleo del kernel ├── scheduler.py ★ Programa agentes-proceso (FIFO / Round-Robin) ├── context_manager.py Snapshot / restore / migrate de agentes ├── memory_manager.py RAM volátil por agente (desaparece al reiniciar) ├── storage_manager.py Disco duradero, compartible entre agentes └── tool_manager.py ToolCall mediante syscall, auditable aios/config/config.yaml scripts/run_terminal.py · run_web.py Cerebrum/ SDK: Agent base · wrappers de syscall · @tool · hub aios-rs/ Reescritura experimental del kernel en Rust