Sandboxes para IA: E2B y Modal para que los agentes ejecuten código de forma segura

Tiempo: unos 25 min de lectura + 35 min de práctica

Lo esencial

Cuando un agente escribe y ejecuta código, ¿quién responde por lo que ese código haga? Si el agente corre rm -rf / o borra por accidente una base de datos, las consecuencias caen en tu computadora, en la de tu cliente o en producción.

Los sandboxes (entornos aislados) resuelven el problema de raíz: el agente recibe un entorno aislado, un contenedor virtual, donde puede ejecutar cualquier código, leer y escribir archivos y hacer solicitudes de red. Pero todo eso pasa dentro de una "jaula". Afuera, el mundo queda intacto.

🎨 Imagínalo así: un sandbox es como la guantera del auto donde guardas todo lo que se puede derramar, regar o explotar. El auto en sí se queda limpio.

En esta lección veremos las dos herramientas principales: E2B, sandboxes hechos especialmente para agentes de IA, y Modal, una plataforma serverless (sin servidores propios que administrar) para tareas de machine learning y cálculos pesados.

Conceptos clave

• Sandbox: un entorno aislado para ejecutar código, con acceso limitado a recursos externos
• Containerization (contenedores): la tecnología (Docker) que aísla procesos a nivel del sistema operativo
• Stateful sandbox: un sandbox que conserva su estado entre llamadas (archivos, paquetes instalados, variables)
• Cold start (arranque en frío): el tiempo que tarda un sandbox en arrancar desde cero; en E2B es del orden de un segundo (cifras exactas en la documentación de E2B)
• Filesystem access (acceso a archivos): el agente puede leer y escribir archivos dentro del sandbox, como en una computadora normal
• Network isolation (aislamiento de red): el sandbox puede tener o no acceso a internet (según la configuración)
• Pay-per-use (pago por uso): ambas herramientas cobran por el tiempo real de uso, no por un servidor fijo
• GPU sandbox: Modal da acceso a GPU para tareas de machine learning sin rentar servidores caros

Teoría

Por qué los agentes necesitan sandboxes

Imagina que contrataste a un programador que trabaja a distancia. Confías en él, pero en su computadora están tus datos, tus claves de API y tu base de datos de producción. Hasta un error accidental puede salir caro.

Con los agentes de IA la situación es más delicada: el agente no solo escribe código, también lo ejecuta. Y si entendió mal la tarea, escribió un script destructivo o cayó en una prompt injection (instrucciones maliciosas escondidas en el texto), sin aislamiento las consecuencias se salen al instante de lo planeado.

Los tres escenarios principales donde hace falta aislar:

1. Ejecutar código no confiable. Un agente programador que escribe y prueba código según lo que pide el usuario. El código puede ser correcto en su lógica, pero peligroso por sus efectos secundarios.

2. Analizar datos sin riesgo. Un agente analista al que le das un CSV, un Excel o una base de datos para investigar. Es mejor que trabaje con una copia en el sandbox, no con el original.

3. Probar antes de producción. Un agente de despliegue comprueba que la compilación funciona, corre las pruebas y solo entonces da luz verde al despliegue real.

🎨 Imagínalo así: el sandbox para un agente es como el laboratorio de un químico. Ahí puedes mezclar lo que sea, las explosiones están permitidas, y justo para eso hay campana de extracción, bata y lentes de seguridad. Nadie entra a la sala de su casa con los reactivos.

E2B: sandboxes hechos para agentes de IA

E2B (e2b.dev) es una empresa que hizo una sola cosa y la hizo bien: microcomputadoras virtuales para que los agentes ejecuten código.

Características clave de E2B:

• Arranque rápido: del orden de un segundo. Un contenedor Docker común suele tardar bastante más en arrancar. E2B usa máquinas virtuales ligeras basadas en Firecracker (una tecnología de AWS) que levantan un entorno aislado muy rápido.

• SDK para Python y JavaScript. Controlas el sandbox con código: lo creas, ejecutas un comando, recibes el resultado, lo cierras.

• Sistema de archivos persistente. Los archivos que el agente crea en el sandbox se conservan durante toda la sesión. Al terminar puedes descargar el resultado.

• Acceso a la red. Por defecto, el sandbox tiene salida a internet: el agente puede descargar paquetes y hacer solicitudes a APIs.

• Plantillas personalizadas. Puedes crear tu propio template con las dependencias ya instaladas, para no instalarlas cada vez.

Ejemplo: un agente programador en Python con E2B:

import anthropic
from e2b_code_interpreter import Sandbox

client = anthropic.Anthropic()

# Creamos el sandbox
sandbox = Sandbox.create()

# Prompt para el agente
user_task = """
Escribe un script de Python que:
1. Genere 100 números aleatorios del 1 al 1000
2. Calcule la media, la mediana y la desviación estándar
3. Haga un histograma y lo guarde en el archivo histogram.png
Ejecuta el script y muestra los resultados.
"""

# El agente genera el código (modelos vigentes: página «Lo vigente»)
response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=2048,
    messages=[{"role": "user", "content": user_task}]
)


def extract_code(text: str) -> str:
    """El modelo suele envolver el código en ```python ... ```: sacamos solo el código."""
    if "```" not in text:
        return text
    block = text.split("```")[1]
    return block.removeprefix("python").strip()


# Extraemos el código de la respuesta del agente
agent_code = extract_code("".join(b.text for b in response.content if b.type == "text"))

# Ejecutamos el código del agente en el sandbox aislado
execution = sandbox.run_code(agent_code)

# Obtenemos los resultados
print("Stdout:", execution.logs.stdout)
print("Stderr:", execution.logs.stderr)

# Descargamos el archivo resultante
if execution.results:
    for result in execution.results:
        if hasattr(result, 'png'):
            with open("histogram.png", "wb") as f:
                f.write(result.png)
            print("Histograma guardado en histogram.png")

# Cerramos el sandbox (libera todos los recursos)
sandbox.kill()

Escenarios de uso de E2B:

• Asistente de programación con IA: el usuario pide un script, el agente escribe el código, lo prueba en el sandbox, corrige errores y entrega un resultado que funciona
• Agente de análisis de datos: subes un archivo de datos, el agente lo analiza, hace gráficas y te devuelve hallazgos
• Agente de web scraping: el agente escribe y prueba un extractor de datos (parser) en un entorno seguro, sin riesgo de que bloqueen la IP de producción
• Revisión de código con ejecución: el agente no solo lee el código, también corre las pruebas y revisa casos límite (edge cases)

Modal: serverless para machine learning y tareas pesadas

Modal (modal.com) es otra clase de herramienta. No es solo un sandbox para código: es una plataforma serverless completa, enfocada en tareas de machine learning.

Lo que hace Modal y E2B no:

• GPU bajo demanda. Puedes correr una función en L4, A10, A100, H100 y otras GPU, y pagas solo el tiempo de GPU. No necesitas un servidor dedicado.

• Tareas programadas (scheduled jobs). Ejecutar funciones con horario (cron), como GitHub Actions pero con acceso a GPU y a un entorno de Python.

• Web endpoints. Publicar endpoints de API a partir de funciones de Python con un solo comando.

• Almacenamiento con Volume. Almacenamiento permanente para modelos, datasets y resultados.

• Tareas en paralelo. Correr miles de tareas en paralelo sin montar infraestructura.

🎨 Imagínalo así: si E2B es la guantera para los experimentos peligrosos del agente, Modal es un instituto científico completo con supercomputadora, laboratorios y horarios. Usas solo lo que necesitas y pagas el tiempo que de verdad consumiste.

Ejemplo: correr un modelo de machine learning en GPU con Modal:

import modal

app = modal.App("ai-inference")

# Imagen con las dependencias
image = modal.Image.debian_slim().pip_install(
    "torch", "transformers", "pillow"
)

@app.function(
    image=image,
    gpu="A10",           # tipo de GPU: la lista de valores válidos está en la documentación de Modal
    timeout=300
)
def run_inference(prompt: str) -> str:
    from transformers import pipeline
    
    generator = pipeline("text-generation", model="gpt2")
    result = generator(prompt, max_length=200)
    return result[0]["generated_text"]

# Ejecución desde un script local (Modal levanta la instancia con GPU por su cuenta)
if __name__ == "__main__":
    with modal.enable_output():
        with app.run():
            result = run_inference.remote("Write a short story:")
            print(result)

E2B vs. Modal: cuándo usar cada uno

Conclusión: E2B es para agentes que escriben y ejecutan código arbitrario. Modal es para agentes que necesitan recursos de cómputo serios (inferencia, ajuste fino o fine-tuning, procesamiento por lotes).

Otras alternativas

Daytona: una alternativa a E2B de código abierto que puedes alojar tú mismo. Si la privacidad importa (ejecutas código de clientes), la puedes levantar en tu propio servidor. Admite las mismas operaciones: crear el entorno, ejecutar código, sistema de archivos.

Docker directamente: si quieres control total y estás dispuesto a configurarlo tú. Más flexibilidad, pero también más trabajo. No trae integración con agentes de IA.

GitHub Codespaces / Gitpod (ahora Ona): entornos para desarrollar, no para agentes. Demasiado pesados y caros para usarlos en cada solicitud.

Seguridad: lo que el agente PUEDE y NO PUEDE hacer en el sandbox

Puede:

• Leer y escribir archivos dentro del sandbox
• Ejecutar cualquier comando de shell (bash, python, node...)
• Instalar paquetes con pip, npm, apt
• Hacer solicitudes HTTP hacia afuera (si la red está permitida)
• Usar CPU y RAM dentro de los límites

No puede (está aislado):

• Acceder a los archivos de tu computadora
• Leer las variables de entorno de la máquina anfitriona
• Cambiar nada fuera del contenedor
• Usar más CPU/RAM de la asignada

Nota importante: E2B abre el acceso a la red por defecto. Si el agente en el sandbox recibe un prompt malicioso y quiere sacar datos (exfiltrar), técnicamente puede hacer una solicitud HTTP a un servidor externo. Para escenarios donde no quieres correr ningún riesgo, E2B permite aislar la red.

🎨 Imagínalo así: un sandbox es una cárcel con patio. El preso no sale de los muros, pero con un recado escondido puede pedirle a un cómplice de afuera que haga algo. La seguridad completa también exige vigilar las solicitudes que salen.

Costo

Ambos servicios cobran por segundo de uso real: el tiempo inactivo no se cobra, y en los dos puedes empezar gratis. En E2B hay un plan gratuito (Hobby) con créditos de una sola vez al registrarte y límites de sandboxes simultáneos y de duración de la sesión, y un plan Pro con cuota mensual más consumo, sesiones más largas y más sandboxes simultáneos. Modal tiene un plan inicial (Starter) sin cuota mensual que incluye créditos cada mes; el tiempo de GPU cuesta bastante más que el de CPU, y los sandboxes salen más caros que las funciones normales.

Las tarifas cambian, así que no damos cifras aquí: antes de planear un presupuesto, revisa las vigentes en las páginas oficiales e2b.dev/pricing y modal.com/pricing. Para estimar una tarea, multiplica su duración en segundos por los recursos que usa (vCPU, memoria, GPU) y por la tarifa publicada. Una tarea corta de un agente en la configuración por defecto de E2B suele costar una fracción de centavo, pero haz tú la cuenta con los precios del día.

Precios y versiones vigentes: Lo vigente.

Práctica

Tarea: construir un agente de análisis de datos que reciba un archivo CSV, haga el análisis en un sandbox de E2B y devuelva un reporte.

Paso 1: Instalación y configuración

# Instalar el SDK
pip install e2b-code-interpreter anthropic

# Obtener las claves de API
# E2B: https://e2b.dev/dashboard → API Keys
# Agregar a .env:
# E2B_API_KEY=e2b_...
# ANTHROPIC_API_KEY=sk-ant-...

Paso 2: Crear un sandbox básico

from e2b_code_interpreter import Sandbox
import os

# Crear el sandbox
sbx = Sandbox.create(api_key=os.environ["E2B_API_KEY"])

# Comprobar que funciona
result = sbx.run_code("print('¡Sandbox en marcha!')")
print(result.logs.stdout)  # ['¡Sandbox en marcha!\n']

# Instalar dependencias (una vez por sesión)
sbx.run_code("import subprocess; subprocess.run(['pip', 'install', 'pandas', 'matplotlib', 'seaborn'], capture_output=True)")

print("Sandbox listo")
sbx.kill()

Paso 3: Subir los datos al sandbox

from e2b_code_interpreter import Sandbox
import anthropic, os

def analyze_csv(csv_path: str) -> dict:
    sbx = Sandbox.create(api_key=os.environ["E2B_API_KEY"])
    
    # Subimos el CSV al sandbox
    with open(csv_path, "rb") as f:
        csv_content = f.read()
    
    sbx.files.write("/home/user/data.csv", csv_content)
    
    # Comprobamos
    result = sbx.run_code("""
import pandas as pd
df = pd.read_csv('/home/user/data.csv')
print(f"Filas cargadas: {len(df)}")
print(f"Columnas: {list(df.columns)}")
print(df.dtypes)
    """)
    
    print("Datos en el sandbox:")
    print(result.logs.stdout)
    
    return sbx  # lo devolvemos para seguir trabajando

Paso 4: El agente analiza los datos

def run_ai_analysis(sbx, question: str) -> str:
    client = anthropic.Anthropic()
    
    # Obtenemos la estructura de los datos
    structure = sbx.run_code("""
import pandas as pd
df = pd.read_csv('/home/user/data.csv')
print(df.describe().to_string())
print("\\nPrimeras filas:")
print(df.head().to_string())
    """)
    
    data_info = "\n".join(structure.logs.stdout)
    
    # Le pedimos al agente que escriba el código de análisis
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=2048,
        system="""Eres analista de datos. Escribe código de Python limpio para analizar datos.
        Los datos ya están cargados en /home/user/data.csv.
        Usa pandas, matplotlib, seaborn.
        Guarda las gráficas como /home/user/plot.png.
        Al final, muestra conclusiones breves con print().""",
        messages=[{
            "role": "user",
            "content": f"Datos:\n{data_info}\n\nTarea: {question}"
        }]
    )
    
    # Extraemos el código de la respuesta (la función extract_code del primer ejemplo)
    code = extract_code("".join(b.text for b in response.content if b.type == "text"))
    
    # Ejecutamos el código del agente en el sandbox
    execution = sbx.run_code(code)
    
    analysis_output = "\n".join(execution.logs.stdout)
    errors = "\n".join(execution.logs.stderr)
    
    if errors:
        print(f"Advertencias: {errors}")
    
    return analysis_output

Paso 5: El pipeline completo, con los resultados

def full_analysis_pipeline(csv_path: str, question: str):
    print(f"Iniciando el análisis: {question}")
    
    sbx = Sandbox.create(api_key=os.environ["E2B_API_KEY"])
    
    try:
        # Subimos los datos
        with open(csv_path, "rb") as f:
            sbx.files.write("/home/user/data.csv", f.read())
        
        # Instalamos dependencias
        sbx.run_code("import subprocess; subprocess.run(['pip', 'install', 'pandas', 'matplotlib', 'seaborn', '-q'], capture_output=True)")
        
        # El agente analiza
        result = run_ai_analysis(sbx, question)
        print("\n=== Resultados del análisis ===")
        print(result)
        
        # Descargamos la gráfica si existe
        try:
            plot_data = sbx.files.read("/home/user/plot.png")
            with open("analysis_result.png", "wb") as f:
                f.write(plot_data)
            print("\nGráfica guardada: analysis_result.png")
        except Exception:
            print("No se generó ninguna gráfica")
            
    finally:
        sbx.kill()
        print("Sandbox cerrado")

# Ejecución
if __name__ == "__main__":
    full_analysis_pipeline(
        csv_path="sales_data.csv",
        question="Encuentra los 5 productos con más ingresos y muestra la evolución de las ventas por mes"
    )

Herramientas y recursos

Ideas clave

"Un agente sin sandbox es un cirujano sin guantes. Tal vez no pase nada. Pero ¿para qué arriesgarse?"

"E2B resuelve una sola tarea: darle al agente un lugar seguro para ejecutar código. No es un gasto extra: es el estándar profesional para sistemas de IA en producción."

"Modal no es un sandbox, es una supercomputadora bajo demanda. Si E2B es la guantera para experimentos, Modal es un laboratorio con GPU. Para los agentes de machine learning, la diferencia es de fondo."

Siguiente lección

→ Agentes de navegador: Browserbase, Stagehand y la automatización web

Los agentes no solo escriben código: también pueden manejar un navegador. En la siguiente lección veremos cómo darle a un agente la capacidad de abrir sitios, llenar formularios, extraer datos y automatizar tareas web con Browserbase y Stagehand.