Sandbox para agentes de IA: ejecuta código aislado sin abrir producción

Un sandbox para agentes de IA no es una casilla de «confía en el agente»: es una frontera de capacidades que limita filesystem, red, identidad, tiempo, recursos y datos. El modelo propone una acción; la política y el runtime deciden si puede ejecutarse.

Modelo de amenazas: qué debes asumir

Trata el prompt, los archivos recuperados, la salida de una tool y el código generado como entradas no confiables. Un prompt injection puede intentar revelar instrucciones, leer un secreto montado o convencer al agente de usar una herramienta fuera de objetivo.

También debes cubrir fallos menos vistosos: fuga por DNS o proxy, credenciales heredadas del entorno, volúmenes persistentes compartidos, imágenes base vulnerables, abuso de CPU o memoria, procesos huérfanos, cachés entre tenants y logs que copian secretos.

El atacante no necesita escapar del contenedor para causar daño. Le basta con usar una identidad válida con demasiado alcance, exfiltrar datos por un dominio permitido o dejar un artefacto que otro paso consuma sin verificar.

Sesión, identidad y workspace

Asocia cada ejecución a un conversation_id, tenant_id y session_id distintos. El workspace nace vacío o con un checkout filtrado, tiene una cuota de disco y se destruye al finalizar; si necesitas reanudar, conserva solo artefactos explícitos y vuelve a validar su procedencia.

Broker de comandos con policy gate

Un broker estrecho transforma una intención validada en un proceso con cwd, entorno, timeout y recursos conocidos. Este ejemplo no entrega un shell al modelo: solo permite ejecutar un runner de tests dentro de /workspace y devuelve stdout/stderr truncados.

import { spawn } from "node:child_process";
import path from "node:path";

const ALLOWED = new Set(["pytest", "npm"]);
const ROOT = path.resolve("/workspace");

export async function runCommand(input: { bin: string; args: string[] }) {
  if (!ALLOWED.has(input.bin) || input.args.some((arg) => arg.startsWith("-c") || arg.includes(".."))) {
    throw new Error("command_denied");
  }
  const args = input.bin === "pytest" ? ["-q", ...input.args] : ["test", "--", ...input.args];
  const child = spawn(input.bin, args, {
    cwd: ROOT,
    env: { PATH: process.env.PATH ?? "" },
    shell: false,
    stdio: ["ignore", "pipe", "pipe"],
  });
  const timer = setTimeout(() => child.kill("SIGKILL"), 15_000);
  const chunks: Buffer[] = [];
  child.stdout.on("data", (chunk) => chunks.push(chunk));
  child.stderr.on("data", (chunk) => chunks.push(chunk));
  return await new Promise((resolve, reject) => child.on("close", (code) => {
    clearTimeout(timer);
    resolve({ code, output: Buffer.concat(chunks).toString("utf8").slice(-8_000) });
  }).on("error", reject));
}

En producción añade validación de esquema, límites de CPU y memoria, una allowlist de rutas y un proxy de red. El broker tampoco debe interpretar texto devuelto por el proceso como una nueva orden sin pasar otra vez por la política.

Haz que una denegación sea visible y accionable. Un sandbox que oculta el motivo del rechazo empuja al equipo a ampliar permisos hasta que «funcione». La policy versionada y las métricas de denegación permiten corregir el contrato sin abrir una puerta global.

Efímero o persistente: cómo decidir

Elige efímero cuando el trabajo sea compilación, tests, análisis de una PR, generación de artefactos o ejecución con datos sintéticos. Reduce contaminación entre sesiones y hace más claro el borrado, a cambio de pagar arranque, checkout y caché.

Elige persistencia controlada cuando una tarea larga necesite checkpoints o una dependencia pesada. Persiste un volumen separado por tenant y conversación, cifra, limita retención y restaura desde snapshots verificables; nunca compartas un workspace por conveniencia.

Mide p95 de arranque, tiempo de preparación, cache hit rate, coste por minuto, coste de almacenamiento y tasa de reintentos. La sesión más barata por ejecución puede ser más cara si deja incidentes o exige revisar demasiados permisos.

Conclusión

La arquitectura ganadora no intenta convencer al modelo de que sea prudente: hace que la prudencia sea una propiedad del runtime. Un sandbox efímero, una identidad estrecha, egress controlado, secretos fuera del proceso, cuotas, auditoría y evals convierten la ejecución de código en una capacidad gobernada y revocable.