Documentacion

OmniArena

Capa de ejecucion bare-metal para agentes IA. Binario de 186KB. Defensa de 6 capas con seccomp-bpf. Identidad y rate limiting por agente. SDKs Python + JavaScript. Cero dependencias.

Que es OmniArena?

OmniArena no es un agente de IA. No piensa, no decide, no genera codigo. Es la capa de ejecucion que se ubica entre tu agente de IA y el sistema operativo.

Cuando un agente de IA (OpenClaw, Claude Code, LangChain, CrewAI, o cualquier agente personalizado) necesita ejecutar un comando shell, OmniArena lo recibe via HTTP, lo verifica contra la politica de seguridad activa, y lo ejecuta dentro de un entorno controlado a nivel kernel con 6 capas de defensa: filtrado de comandos, namespace de red (sin conectividad), jail de filesystem (chroot + bind mounts read-only), limites de recursos, restricciones de privilegios y filtro seccomp-bpf a nivel kernel (bloquea 17 syscalls peligrosos incluyendo socket, connect, ptrace). Si el comando es peligroso, OmniArena lo bloquea antes de que llegue al kernel.

Como encaja en el stack

Tu → "crea una app en Python que calcule fibonacci"

Agente IA → decide que comandos ejecutar

OmniArena → ejecuta o bloquea, registra todo

Kernel → hardware

Distincion importante

OmniArena no reemplaza tu framework de agentes. Lo complementa. Tu agente decide que hacer. OmniArena controla como se ejecuta a nivel de sistema — con aislamiento de procesos, limites de recursos, politicas de seguridad y logging de auditoria completo. Si el agente comete un error, OmniArena es la ultima barrera antes del kernel.

Inicio Rapido

Instalar OmniArena

Un comando. Instala binario + dashboard + servicio systemd. 186KB, cero dependencias.

# Instalar OmniArena (descarga binario + dashboard + servicio systemd)
curl -sSL https://getomnios.com/install/omniarena.sh | sudo bash

# O descargar manualmente:
curl -fsSL https://getomnios.com/downloads/omniarena/omniarena-linux -o omniarena
chmod +x omniarena
sudo ./omniarena   # root = aislamiento completo de 6 capas (namespaces + seccomp-bpf)

Conectar tu agente IA

Elige tu metodo de integracion. Todos los agentes obtienen ejecucion aislada, rate limiting, log de auditoria y proteccion seccomp-bpf a nivel kernel automaticamente.

Para OpenClaw y cualquier agente compatible con MCP. Un script lo configura todo: servidor MCP, mcporter y auto-inicio.

# 1. Iniciar OmniArena (si no esta corriendo)
sudo omniarena &

# 2. Ejecutar el script de integracion con OpenClaw (descarga MCP bridge + configura mcporter)
curl -fsSL https://getomnios.com/downloads/omniarena/omniarena-setup.sh | bash

# 3. Listo! OpenClaw ahora ejecuta comandos a traves de OmniArena.
#    Pide a tu agente: "Lista los archivos en /tmp usando el sandbox"
#    Cada comando es aislado, logueado y rate-limited automaticamente.

Para LangChain, CrewAI, AutoGPT, o cualquier agente Python. Reemplaza subprocess.run() con arena.exec().

pip install omniarena

from omniarena import Arena

arena = Arena()  # conecta a localhost:7575
result = arena.exec("echo hola", agent="mi-agente", model="claude-opus-4",
                     tokens_in=100, tokens_out=30)
print(result.stdout)  # "hola\n"

# Funciona con LangChain, CrewAI, o cualquier agente Python:
# Solo reemplaza subprocess.run() con arena.exec()

Para agentes Node.js. Fetch nativo, cero dependencias, definiciones TypeScript incluidas.

import { Arena } from 'omniarena'

const arena = new Arena()  // conecta a localhost:7575
const result = await arena.exec("echo hola", {
  agent: "mi-agente", model: "gpt-4o",
  tokensIn: 100, tokensOut: 30
})
console.log(result.stdout)  // "hola\n"

Para cualquier lenguaje o framework. OmniArena es una API HTTP estandar — solo envia JSON por POST.

# Cualquier lenguaje, cualquier framework — solo HTTP POST
curl -u arena:omniarena -X POST http://localhost:7575/api/exec \
  -H "Content-Type: application/json" \
  -H "X-Agent: mi-agente" \
  -d '{"cmd":"echo hola","tokens_in":100,"tokens_out":30,"model":"claude-opus-4"}'

# Respuesta:
# {"ok":true,"stdout":"hola\n","stderr":"","exit_code":0,"duration_ms":1}

# Comando bloqueado:
curl -u arena:omniarena -X POST http://localhost:7575/api/exec \
  -d '{"cmd":"rm -rf /"}'
# {"ok":false,"error":"command blocked by blacklist"}

Verificar

# Verificar estado
curl -u arena:omniarena http://localhost:7575/api/health

# Ver todos los agentes registrados y sus metricas
curl -u arena:omniarena http://localhost:7575/api/agents

# Log de auditoria
curl -u arena:omniarena http://localhost:7575/api/audit

Valores por defecto

Puerto: 7575 Auth: arena:omniarena Perfil: estricto Rate limit: 20 req/s global Por agente: 30 req/min Aislamiento: 6 capas + seccomp-bpf

Dashboard

Abre http://localhost:7575 en tu navegador. No requiere autenticacion.

Que ves

▸ 7 tarjetas de metricas — ejecuciones totales, comandos bloqueados, bytes capturados, uptime, perfil activo, nivel de aislamiento, tamano del binario
▸ Terminal del sandbox — un campo de texto para ejecutar comandos shell manualmente
▸ Selector de perfil — cambiar entre estricto, moderado y permisivo
▸ Log de auditoria — ultimos 20 eventos, se actualiza automaticamente cada 3 segundos

El campo de texto no es un chat

El campo de entrada en el dashboard ejecuta comandos shell directos (como ls -la o python3 -c 'print(1+1)'). No entiende lenguaje natural. Es lo mismo que llamar a POST /api/exec manualmente. Usalo para testing y monitoreo — tu agente IA llama a la API directamente.

Flujo de trabajo tipico

Tu agente IA trabaja en la terminal (via MCP o HTTP). Tu abres el dashboard en el navegador para supervisar en tiempo real: ver que comandos esta ejecutando el agente, cuales fueron bloqueados, y el historial de auditoria completo. Piensa en el dashboard como una sala de control.

Referencia API

Todos los endpoints requieren HTTP Basic Auth (arena:omniarena). CORS habilitado. Dashboard en GET / sin auth.

GET /api/health

Estado del sandbox: perfil activo, conteo de ejecuciones, uptime, limites de recursos.

{
  "ok": true,
  "version": "1.0.4",
  "uptime_sec": 3600,
  "total_execs": 42,
  "blocked_cmds": 3,
  "profile": "strict",
  "isolation": "kernel",
  "agents_count": 3,
  "max_rate_per_agent": 30,
  "default_token_budget": 0,
  "binary_size": "~186KB",
  "dependencies": 0
}

POST /api/exec

Ejecutar un comando shell. Se verifica contra la politica de seguridad activa.

Request

{ "cmd": "ls -la /tmp" }

Exito (200)

{
  "ok": true,
  "stdout": "total 0\ndrwxrwxrwt 2 root root 40 ...",
  "stderr": "",
  "exit_code": 0,
  "duration_ms": 5,
  "files": ["output.txt", "data.csv"]
}

Bloqueado (403)

{
  "ok": false,
  "error": "command blocked by blacklist"
}

POST /api/profile

Cambiar perfil de seguridad. Efecto inmediato.

Request

{ "profile": 1 }

Respuesta

{
  "ok": true,
  "profile": 1,
  "timeout_ms": 30000,
  "max_mem_mb": 256,
  "max_cpu_sec": 30
}

GET /api/agents

Agentes registrados con metricas: ejecuciones, bloqueados, bytes, tasa, tokens consumidos y modelo.

{
  "agents": [
    {
      "name": "claude-agent",
      "execs": 142,
      "blocked": 3,
      "bytes": 28400,
      "rate_1m": 5,
      "last_active": 1711036800,
      "tokens_in": 15000,
      "tokens_out": 8200,
      "tokens_total": 23200,
      "token_budget": 50000,
      "model": "claude-4"
    }
  ],
  "count": 1,
  "max": 8,
  "rate_limit": 30
}

GET /api/audit

Log de auditoria. Cada ejecucion registrada con timestamp, comando, resultado y codigo de salida.

{
  "entries": [
    "[00:01:23] EXEC ls -la → exit:0 OK",
    "[00:01:25] BLOCK rm -rf / → exit:0 BLACKLIST",
    "[00:02:10] CONFIG set_profile → exit:1 OK"
  ]
}

POST /api/budget

Establecer presupuesto de tokens por agente o default global. Cuando un agente excede su presupuesto, todos los comandos son rechazados con 429.

# Presupuesto por agente
curl -u arena:omniarena -X POST http://localhost:7575/api/budget \
  -H 'Content-Type: application/json' \
  -d '{"agent":"claude-agent","max_tokens":50000}'

# Presupuesto global por defecto
curl -u arena:omniarena -X POST http://localhost:7575/api/budget \
  -H 'Content-Type: application/json' \
  -d '{"default":100000}'

# Respuesta: {"ok":true,"agent":"claude-agent","max_tokens":50000}

POST /api/policy/reload

Recarga en caliente de politica desde /etc/omniarena/policy.conf. Actualiza blacklist, whitelist y config sin reiniciar.

curl -u arena:omniarena -X POST http://localhost:7575/api/policy/reload

# Respuesta: {"ok":true,"blacklist_count":17,"whitelist_count":14,"profile":0}

# Formato del archivo (/etc/omniarena/policy.conf):
# [blacklist]
# rm -rf /
# wget
# [whitelist]
# ls
# echo
# [config]
# profile=0
# default_token_budget=50000

DELETE /api/sandbox

Reiniciar sandbox: limpiar log de auditoria y contadores.

{ "ok": true, "message": "sandbox reset" }

Perfiles de Seguridad

Perfil	Politica	Timeout	Mem	CPU	Procs
0 — Estricto	Solo whitelist	5s	64MB	5s	5
1 — Moderado	Blacklist	30s	256MB	30s	10
2 — Permisivo	Solo auditoria	5min	1GB	5min	50

# Cambiar a moderado
curl -u arena:omniarena -X POST http://localhost:7575/api/profile \
  -d '{"profile": 1}'

# Volver a estricto
curl -u arena:omniarena -X POST http://localhost:7575/api/profile \
  -d '{"profile": 0}'

Motor de Politicas

Blacklist (siempre bloqueado)

rm -rf /dd if=mkfs:() (fork bomb)wget, curlnetcat, nmapchmod 777, chown rootshutdown, reboot/etc/shadow, /etc/passwd.ssh/id_, /dev/sda

Whitelist (modo estricto)

ls, cat, echo, pwdhead, tail, wcgrep, finddate, whoami, unamepython3, node

Estricto: El comando debe comenzar con un comando de la whitelist. La blacklist tambien se verifica.

Moderado: Solo se bloquean los comandos de la blacklist. Todo lo demas permitido.

Permisivo: Nada se bloquea. Todo se audita.

Aislamiento Kernel

Cuando se ejecuta como root, OmniArena aplica 6 capas de aislamiento a nivel kernel en cada ejecucion de comando. Esto proporciona aislamiento nivel Docker sin Docker.

Capa	Mecanismo	Que protege
1	Blacklist	Fast-path: rechaza antes de fork (ahorra recursos)
2	CLONE_NEWNET	Stack de red vacio: sin HTTP, sin reverse shells, sin exfiltracion
3	CLONE_NEWNS + chroot	Filesystem aislado: solo /bin, /usr/bin, /lib (solo lectura) + /tmp (tmpfs escribible)
4	setrlimit x5	CPU, RAM, procesos, tamano de archivo, descriptores
5	NO_NEW_PRIVS	Sin escalacion de privilegios via binarios SUID
6	seccomp-bpf	Bloquea 17 syscalls peligrosos (socket, connect, ptrace, reboot...) a nivel kernel — ineludible

Como root (aislamiento kernel)

Red: completamente aislada (sin loopback) Filesystem: jail chroot en /var/arena/jail Visible: /bin, /usr/bin, /lib, /lib64 (solo lectura) Escribible: solo /tmp (tmpfs fresco por ejecucion) Invisible: /etc, /home, /root, /proc, /sys API Health: "isolation": "kernel"

Sin root (aislamiento basico)

Motor de politicas blacklist + whitelist Limites de recursos setrlimit (CPU, RAM, procs) Restriccion de privilegios NO_NEW_PRIVS Logging de auditoria completo Sin aislamiento de namespaces (requiere root) API Health: "isolation": "basic"

Degradacion graceful

OmniArena funciona sin root — automaticamente degrada a aislamiento con blacklist + rlimits. Ejecuta como root para proteccion completa a nivel kernel. El endpoint /api/health reporta el nivel de aislamiento activo para verificacion.

Limites de Recursos

Cada comando se ejecuta en un proceso hijo aislado con limites impuestos por el kernel via setrlimit. Como root, cada comando tambien corre dentro de namespaces Linux (mount, network) con un jail chroot.

Recurso	Descripcion	Signal
RLIMIT_CPU	Max segundos de CPU	SIGKILL
RLIMIT_AS	Max memoria virtual	ENOMEM
RLIMIT_NPROC	Max procesos hijo	EAGAIN
RLIMIT_FSIZE	Max tamano de archivo	SIGXFSZ
RLIMIT_NOFILE	Max descriptores abiertos	EMFILE

Configuracion

Variables globales en tiempo de compilacion en el codigo fuente. Modificar antes de compilar con omnic.

Param	Default	Descripcion
PORT	7575	Puerto HTTP
MAX_RPS	20	Limite de tasa (req/s)
AUTH_USER	arena	Usuario Basic Auth
AUTH_PASS	omniarena	Contrasena Basic Auth
AUDIT_SLOTS	64	Max entradas de log (anillo)
g_profile	0	Perfil inicial (0/1/2)
MAX_AGENTS	8	Max agentes concurrentes
g_max_rate_per_agent	30	Limite de tasa por agente (req/min)
Bearer token	/etc/omniarena/token	Archivo de token Bearer (fallback: omniarena-default-token)