Ejecutá Código Escrito por Agentes Dentro de un Sandbox: Timeouts, Límites y Sin Egress

1. El Problema: El Código Generado Es Input No Confiable

Una tool de code interpreter deja que el modelo calcule en vez de adivinar: parsear un CSV, hacer un gráfico, correr un test. La trampa es que ese código lo escribe un sistema que también lee texto no confiable — páginas web, issues, PDFs, salidas de otras tools. Una prompt injection convierte ‘resumí esta página’ en ‘ejecutá este snippet’, y tenés ejecución remota de código con un paso extra.

La solución no es un producto. Es un stack corto: correr el código en algo descartable, darle un presupuesto de tiempo y otro de recursos, decidir a qué puede llegar la red antes de que arranque y dejar las credenciales afuera. Los proveedores de abajo venden la caja descartable; el resto es política que escribís vos.

2. Conceptos Mínimos Antes de Tocar Código

Seis ideas cubren casi todo. Con esto claro, los snippets de cada proveedor se leen como variaciones de un mismo tema.

3. Cuatro Proveedores, Solo Hechos de Sus Propias Docs

Limité la tabla a lo que cada proveedor afirma en su documentación o su página de precios al 14 de octubre de 2026. Cuando una página no daba un número, la celda lo dice en vez de adivinar. Precios y límites cambian: tomala como un mapa hacia las páginas de Fuentes, no como una cotización.

4. Paso 1 — El Contrato de la Tool y Vercel Sandbox (TypeScript)

Empezá por el contrato, porque es igual para todos los proveedores: el modelo manda código y un presupuesto de tiempo; la tool devuelve stdout, stderr y un exit code, truncados; el host nunca ejecuta nada. Abajo corre sobre Vercel Sandbox (@vercel/sandbox 3.8.0 al publicar): creás un sandbox con egress denegado, escribís el archivo, lo corrés con una señal de abort por comando y siempre frenás la VM.

TypeScript — runCode sobre Vercel Sandbox

import { Sandbox } from "@vercel/sandbox";

const MAX_OUT = 20_000; // characters handed back to the model

export async function runCode(code: string, budgetMs = 15_000) {
  const sandbox = await Sandbox.create({
    timeout: 60_000,           // hard session cap in ms (default 5 min)
    resources: { vcpus: 1 },   // default is 2
    networkPolicy: "deny-all", // blocks egress, DNS included
    persistent: false,         // one-shot: discard the filesystem on stop
  });
  try {
    await sandbox.writeFiles([
      { path: "agent-code.mjs", content: Buffer.from(code) },
    ]);
    const run = await sandbox.runCommand(
      "node",
      ["/vercel/sandbox/agent-code.mjs"],
      { signal: AbortSignal.timeout(budgetMs) }, // aborted call rejects
    );
    return {
      exitCode: run.exitCode,
      stdout: (await run.stdout()).slice(0, MAX_OUT),
      stderr: (await run.stderr()).slice(0, MAX_OUT),
    };
  } finally {
    await sandbox.stop(); // always, even when the call above throws
  }
}

Con deny-all desde el arranque no hay npm ni pip install. Si la tarea necesita paquetes, usá el patrón de actualización en vivo de la doc: instalás con red en un paso de setup confiable, bajás a deny-all y recién entonces corre el código no confiable. Para acceso parcial la política acepta una lista de dominios, y para credenciales existe el brokering: el firewall inyecta el header y el secreto nunca entra al sandbox.

TypeScript — instalar, bloquear o intermediar una credencial

// 1) Trusted setup with network, then lock before untrusted code
const sandbox = await Sandbox.create({ persistent: false }); // allow-all
await sandbox.runCommand("npm", ["install", "mathjs"]);
await sandbox.update({ networkPolicy: "deny-all" });

// 2) Or allow-list only what the task needs
const scoped = await Sandbox.create({
  networkPolicy: { allow: ["ai-gateway.vercel.sh"] },
});

// 3) Or let the firewall inject the credential (secret stays outside)
const brokered = await Sandbox.create({
  networkPolicy: {
    allow: {
      "ai-gateway.vercel.sh": [{
        transform: [{ headers: { Authorization: "Bearer " + process.env.AI_GATEWAY_TOKEN } }],
      }],
    },
  },
});

5. Paso 2 — E2B Code Interpreter (TypeScript y Python)

El @e2b/code-interpreter de E2B te da runCode con un resultado estilo Jupyter, así el agente puede mandar Python de varias líneas y leer errores estructurados. Fijá la vida en la llamada de creación y ojo con las unidades: milisegundos en JavaScript (timeoutMs), segundos en Python (timeout). Apagar internet es un solo flag, y las reglas de red cubren el caso de la allow-list.

TypeScript — sin internet, 60 s de vida

import { Sandbox } from "@e2b/code-interpreter"; // needs E2B_API_KEY

const sbx = await Sandbox.create({
  timeoutMs: 60_000,          // JavaScript: milliseconds
  allowInternetAccess: false, // same as denyOut: ["0.0.0.0/0"]
});
try {
  const execution = await sbx.runCode(aiGeneratedCode);
  if (execution.error) {
    console.error(execution.error.name, execution.error.value);
    console.error(execution.error.traceback);
  } else {
    console.log(execution.logs);
  }
} finally {
  await sbx.kill();
}

En Python la misma idea se escribe en snake_case, y la opción network recibe listas explícitas de allow y deny. Denegar todo el tráfico primero y permitir direcciones puntuales después es la forma que muestra la doc.

Python — denegar todo, permitir dos rangos

from e2b_code_interpreter import Sandbox

sbx = Sandbox.create(
    timeout=60,  # Python: seconds
    network={
        "deny_out": lambda ctx: [ctx.all_traffic],
        "allow_out": ["1.1.1.1", "8.8.8.0/24"],
    },
)
try:
    execution = sbx.run_code(ai_generated_code)
    if execution.error:
        print(execution.error.traceback)
    else:
        print(execution.logs)
finally:
    sbx.kill()

6. Pasos 3 y 4 — Modal y Daytona (Python)

Los Sandboxes de Modal corren comandos en un contenedor que definís en runtime. Podés elegir el runtime — gVisor, o una VM con su propio kernel — o dejarlo sin fijar y que decida Modal. La vida máxima por defecto es de 5 minutos (configurable hasta 24 horas), CPU y memoria son parámetros explícitos y la red se corta con un flag.

Python — Sandbox de Modal con block_network

import modal

app = modal.App.lookup("code-interpreter", create_if_missing=True)

sb = modal.Sandbox.create(
    image=modal.Image.debian_slim().pip_install("pandas"),
    app=app,
    timeout=120,         # seconds of max lifetime (default 300)
    cpu=1.0,             # fractional cores
    memory=1024,         # MiB
    block_network=True,  # drops all outbound traffic
)
try:
    p = sb.exec("python", "-c", ai_generated_code, timeout=15)
    print(p.stdout.read())
    print(p.stderr.read())
    print("exit code:", p.wait())
finally:
    sb.terminate()

Daytona (daytona y @daytona/sdk 0.224.1) crea un sandbox, corre código con process.code_run y recibe un timeout en segundos. Los defaults documentados son 1 vCPU, 1 GB de RAM, 3 GiB de disco y auto-stop tras 15 minutos de inactividad. El egress se fija al crear con network_block_all, network_allow_list o domain_allow_list; son mutuamente excluyentes y una mezcla conflictiva devuelve un 400.

Python — sandbox efímero de Daytona con red bloqueada

from daytona import Daytona, DaytonaConfig, CreateSandboxFromSnapshotParams

daytona = Daytona(DaytonaConfig(api_key="YOUR_API_KEY"))  # read it from env

sandbox = daytona.create(
    CreateSandboxFromSnapshotParams(
        network_block_all=True,  # or domain_allow_list="example.com,*.daytona.io"
        ephemeral=True,          # deleted when stopped
        auto_stop_interval=5,    # minutes of inactivity (default 15)
    )
)
try:
    response = sandbox.process.code_run(ai_generated_code, timeout=10)
    if response.exit_code != 0:
        print("failed:", response.result)
    else:
        print(response.result)
finally:
    sandbox.delete()

7. Una Rutina de Blindaje Alrededor del Sandbox

El proveedor te da la caja. Esta es la rutina que le armo alrededor para que la caja realmente sirva:

8. Errores Comunes (y Qué No Cubre Cada Capa)

La columna izquierda es lo que hacen las integraciones que funcionan; la derecha es lo que aparece en los post-mortems.

Conclusión

Ya tenés el loop completo: un contrato de tool (código y presupuesto adentro, stdout, stderr y exit code afuera), un sandbox descartable en E2B, Vercel Sandbox, Modal o Daytona, egress denegado antes de que corra la primera línea, dos relojes y la salida tratada como no confiable. Los proveedores difieren en tecnología de aislamiento, límites de vida y modelo de precios, pero la política que escribís alrededor es la misma.

Esta semana elegí un proveedor, envolvelo en el contrato runCode de arriba y sumá dos tests de CI: un intento de egress canario y un loop infinito. Si pasan los dos, ‘el agente puede ejecutar código’ deja de ser un pasivo y pasa a ser una feature con un radio de daño medido. Si tu agente además instala skills o clona repos, leé los artículos relacionados de abajo: el sandbox es una capa, no toda la defensa.

Fuentes

• Vercel — Entendiendo los Sandboxes (aislamiento, ciclo de vida, modelo de seguridad)
• Vercel — Firewall del Sandbox (políticas de red, credentials brokering)
• Vercel — Precios y cuotas de Sandbox
• Vercel — Referencia del SDK de JS de Sandbox
• E2B — Quickstart (SDK de code interpreter)
• E2B — Acceso a internet y reglas de red
• E2B — Ciclo de vida del sandbox y timeouts
• E2B — Precios
• Modal — Guía de Sandboxes
• Modal — Redes en Sandboxes
• Modal — Seguridad y responsabilidad compartida
• Modal — Referencia de Sandbox.create
• Daytona — Sandboxes
• Daytona — Límites de red
• Daytona — Precios