Sandboxes alojados por OpenAI: crea un analista financiero de IA seguro

Los agentes de IA han pasado de la simple generación de texto. Ahora pueden escribir código, ejecutar comandos, trabajar con archivos, corregir errores y completar tareas de varios pasos por sí solos.

Pero los LLM no siempre son predecibles. 

Aunque les des instrucciones claras, un agente puede generar un comando inesperado o modificar algo que no debía. Ejecutar ese código directamente en tu equipo local o en el servidor de tu aplicación puede introducir riesgos innecesarios.

En este tutorial, usaré un sandbox alojado por OpenAI para crear un analista financiero de IA seguro. Subiremos un conjunto de datos financieros, conectaremos un agente al entorno aislado, dejaremos que haga el análisis y genere artefactos allí, y después descargaremos los informes, gráficos y archivos resultantes.

El analista financiero es solo un ejemplo. El objetivo es entender cómo darle a un agente de IA un entorno controlado donde pueda ejecutar código y trabajar con archivos de forma segura.

¿Qué es el sandbox alojado por OpenAI?

Un sandbox es un entorno aislado donde puede ejecutarse código sin acceso sin restricciones al sistema que aloja tu aplicación.

Esto es especialmente útil con agentes de IA porque su comportamiento no es completamente predecible. 

Un agente puede recibir la instrucción de modificar un archivo y, sin embargo, generar un comando que afecte a otro directorio, instalar una dependencia inesperada o ejecutar algo que no habías previsto.

En lugar de permitir que esos comandos se ejecuten directamente en tu portátil o servidor, puedes colocar al agente dentro de un sandbox.

OpenAI ofrece su propio entorno de sandbox alojado para este fin. 

Proporciona al agente un espacio de trabajo Linux real con sistema de archivos y shell, manteniendo esa ejecución separada de tu sistema local.

Dentro del sandbox, el agente puede:

• Leer y escribir archivos.
• Crear y ejecutar scripts.
• Ejecutar comandos de shell.
• Inspeccionar la salida de los comandos.
• Corregir errores y volver a ejecutar su código.
• Generar informes, conjuntos de datos, gráficos y otros artefactos.

También puedes controlar a qué tiene acceso el sandbox. 

Por ejemplo, puedes subir solo los archivos necesarios para la tarea y desactivar el acceso a la red cuando el agente no necesite información externa.

Formas de usar los sandboxes de OpenAI

OpenAI te da varias formas de ejecutar agentes o modelos dentro de entornos aislados. La principal diferencia es cuánta ejecución y flujo del agente quieres que gestione OpenAI.

1. Shell tool

La Shell tool es la opción más simple. Permite que un modelo ejecute comandos de shell dentro de un contenedor alojado por OpenAI a través de la Responses API.

response = client.responses.create(
    model=MODEL,
    tools=[{
        "type": "shell",
        "environment": {"type": "container_auto"}
    }],
    input="Analyze the files in /mnt/data."
)Con la tecnología de

Es una buena elección cuando necesitas principalmente ejecución de código, procesamiento de archivos o tareas de línea de comandos.

2. Agents API

La Agents API es una opción más gestionada. OpenAI se encarga tanto de la sesión del agente como del entorno alojado.

stream = client.beta.agents.sessions.create(
    agent={
        "model": MODEL,
        "instructions": "Analyze the data and create a report."
    },
    environment={"type": "openai_hosted"},
    input="Analyze the files in the workspace.",
    stream=True,
)Con la tecnología de

Es útil cuando quieres que OpenAI gestione más la ejecución del agente y el ciclo de vida del sandbox.

3. SandboxAgent

SandboxAgent forma parte del Agents SDK y está pensado para agentes en los que el espacio de trabajo del sandbox es una parte central de la aplicación.

from agents.sandbox import SandboxAgent
from agents.sandbox.capabilities import Shell

agent = SandboxAgent(
    name="Financial Analyst",
    model=MODEL,
    capabilities=[Shell()],
)Con la tecnología de

Funciona bien cuando necesitas espacios de trabajo, archivos y artefactos persistentes, o flexibilidad sobre qué proveedor de sandbox usas.

4. Agents SDK + ShellTool

Este es el enfoque que usamos en esta guía.

Creamos nosotros mismos el contenedor alojado por OpenAI y luego conectamos el agente a ese entorno específico usando ShellTool.

sandbox_shell = ShellTool(
    environment={
        "type": "container_reference",
        "container_id": container.id,
    }
)Con la tecnología de

Elegimos este enfoque porque ofrece un buen equilibrio entre sencillez y control. 

OpenAI gestiona la infraestructura del sandbox, mientras que nosotros controlamos el contenedor, los archivos, el acceso a la red, las instrucciones del agente, las herramientas y el flujo de ejecución.

Cómo usar el sandbox alojado por OpenAI

Vamos a ver cómo usar el sandbox alojado por OpenAI para crear un agente de análisis financiero seguro. 

1. Prepara el entorno y el proyecto

Usaremos un Jupyter Notebook para configurar y probar el flujo de trabajo. 

El notebook se encargará de instalar los SDK necesarios, subir el conjunto de datos, crear el sandbox, iniciar el agente y descargar los artefactos finales.

Sin embargo, la diferencia clave es que el análisis financiero en sí no se ejecutará dentro de Jupyter. 

Una vez que el agente esté conectado al sandbox de OpenAI, la ejecución de código, los comandos de shell, la validación, los cálculos y la generación de artefactos ocurrirán dentro del entorno alojado.

Piensa en Jupyter como la capa de control y en el sandbox como el entorno de ejecución.

Empieza instalando el OpenAI Python SDK y el OpenAI Agents SDK:

%pip install -q -U openai openai-agentsCon la tecnología de

También necesitas una clave de la API de OpenAI disponible mediante la variable de entorno OPENAI_API_KEY.

En este tutorial usaremos un conjunto de datos de una empresa ficticia guardado en:

financial_data/northstar_cloud_financial_statements.csvCon la tecnología de

A continuación, importa las librerías necesarias y define el modelo, el CSV de entrada, el directorio de salida local y los archivos que esperamos que el agente genere.

import json
import os
from pathlib import Path

from IPython.display import Markdown, SVG, display


MODEL = os.getenv("OPENAI_MODEL", "gpt-6-luna")

STATEMENT_CSV = Path(
    "financial_data/northstar_cloud_financial_statements.csv"
)

OUTPUT_DIR = Path("financial_analysis_output")
OUTPUT_DIR.mkdir(exist_ok=True)

EXPECTED_ARTIFACTS = [
    "analyze_financials.py",
    "calculated_metrics.csv",
    "unusual_movements.csv",
    "financial_trends.svg",
    "investment_analysis.md",
    "analysis_run.json",
]

assert os.getenv("OPENAI_API_KEY"), \
    "Set OPENAI_API_KEY before continuing."

assert STATEMENT_CSV.exists(), \
    f"Missing input: {STATEMENT_CSV.resolve()}"

print(f"Model: {MODEL}")
print(
    f"Input: {STATEMENT_CSV} "
    f"({STATEMENT_CSV.stat().st_size:,} bytes)"
)Con la tecnología de

Salida:

Model: gpt-6-luna
Input: financial_data\northstar_cloud_financial_statements.csv (1,480 bytes)Con la tecnología de

Las aserciones hacen una comprobación rápida antes de crear recursos en OpenAI. Si falta la clave de la API o no se encuentra el conjunto de datos, el notebook se detiene de inmediato en lugar de fallar más adelante.

OUTPUT_DIR es un directorio local de Jupyter donde guardaremos los archivos descargados del sandbox. 

EXPECTED_ARTIFACTS, por su parte, define los archivos que esperamos que el agente cree dentro del sandbox.

2. Sube los datos financieros

Antes de que el sandbox pueda trabajar con nuestros datos financieros, primero tenemos que subir el CSV a OpenAI.

El Jupyter Notebook se encarga de este paso. Lee el archivo local y lo envía a través de la Files API de OpenAI.

from openai import OpenAI

client = OpenAI()

with STATEMENT_CSV.open("rb") as handle:
    uploaded_input = client.files.create(
        file=handle,
        purpose="user_data",
    )

print(f"Uploaded raw statements: {uploaded_input.id}")Con la tecnología de

Salida:

Uploaded raw statements: file-C6Pb6RhZrVPR4Fiq9tZ6HnCon la tecnología de

Tu ID de archivo será distinto.

El ID devuelto es importante porque lo usaremos al crear el sandbox. En lugar de copiar el contenido del CSV en un prompt, podemos adjuntar el archivo original directamente al entorno de trabajo del agente.

En este punto, los estados financieros de Northstar están guardados en OpenAI, pero el agente aún no tiene un entorno de ejecución.

Lo crearemos a continuación.

3. Crea el sandbox alojado por OpenAI

Ahora podemos crear el entorno alojado donde el agente realizará el análisis financiero.

Usa la Containers API para crear un nuevo sandbox y adjunta el CSV subido usando su ID de archivo:

container = client.containers.create(
    name="northstar-financial-analysis",
    file_ids=[uploaded_input.id],
    memory_limit="4g",
    network_policy={"type": "disabled"},
)

print(f"OpenAI sandbox: {container.id}")Con la tecnología de

Salida:

OpenAI sandbox: cntr_6ab7a1080b4081938d8d08ab67ac963c084798905ec997e9Con la tecnología de

El sandbox se crea con 4 GB de memoria y los estados financieros subidos están disponibles dentro desde el inicio.

También desactivamos el acceso a la red:

network_policy={"type": "disabled"}Con la tecnología de

Nuestro análisis financiero no requiere información de internet, así que no tiene sentido dar al agente acceso externo. Todo lo que necesita ya está en el CSV.

4. Define la tarea del analista financiero

El sandbox ofrece al agente un lugar seguro para trabajar, pero aún debemos definir exactamente qué debe hacer.

En lugar de darle al modelo una instrucción vaga como "analiza esta empresa", le proporcionamos una tarea detallada que describe los cálculos, las comprobaciones de validación, los archivos a generar y cómo debe verificar su propio trabajo.

ANALYST_INSTRUCTIONS = """
You are a skeptical senior buy-side financial analyst preparing an investment-committee memo.

Every analytical operation must occur in the hosted shell container under /mnt/data. Do not
estimate results mentally or ask the caller to calculate anything.

Find the uploaded Northstar statement CSV. Write analyze_financials.py using only the Python
standard library and execute it. Validate required columns, numeric values, unique ordered years,
and total_assets = total_liabilities + equity for every row. Calculate revenue growth, gross/
operating/net margins, current and quick ratios, total-liabilities-to-equity, average-balance ROA
and ROE, interest coverage, free cash flow, FCF margin, cash conversion, receivables growth, and
inventory growth. Leave a ratio blank when its denominator makes it undefined.

Flag absolute year-over-year movements of at least 15%, operating-margin moves of at least two
percentage points, and receivables growth exceeding revenue growth by at least ten points. Create
calculated_metrics.csv, unusual_movements.csv, financial_trends.svg, investment_analysis.md, and
analysis_run.json in /mnt/data. The SVG must contain four readable chart panels without external
packages.

The report must cover Executive view, KPI table, Profitability, Liquidity and leverage, Cash flow
and earnings quality, Unusual movements, Bull case, Bear case, Diligence questions, Data
limitations, and Conclusion. Tie receivables, deferred revenue, stock compensation, capex, and
interest expense to evidence; separate facts from hypotheses and cite filenames and years.

analysis_run.json must contain input_filename, row_count, year_range, validation_results,
generated_filenames, and execution_directory='/mnt/data'. validation_results must include
accounting_equation_passed_every_row=true. Run the script, inspect every artifact, independently
recompute at least three 2025 metrics in a second command, and fix discrepancies. Do not finish
until all six required files exist and are non-empty.
"""Con la tecnología de

Aquí hay una decisión de diseño importante.

No le pedimos al modelo que razone todo el análisis financiero solo en su respuesta. 

Las instrucciones le dicen explícitamente que escriba código, lo ejecute, inspeccione los resultados, verifique ciertos cálculos y corrija cualquier discrepancia.

También indicamos al agente que toda operación analítica debe ocurrir bajo /mnt/data dentro del sandbox alojado.

Esto le da al agente un flujo de trabajo claro:

Encontrar los datos → validarlos → escribir el script de análisis → ejecutarlo → generar artefactos → inspeccionar los resultados → verificar cálculos → corregir errores si hace falta.

Así el sandbox se convierte en un entorno de trabajo real y no solo en un almacenamiento temporal de archivos.

5. Conecta el agente al sandbox

Ahora conectamos un agente de OpenAI al contenedor que creamos antes.

Lo hacemos usando ShellTool.

from agents import Agent, ModelSettings, Runner, ShellTool

sandbox_shell = ShellTool(
    environment={
        "type": "container_reference",
        "container_id": container.id,
    }
)

analyst = Agent(
    name="Sandbox Financial Analyst",
    model=MODEL,
    instructions=ANALYST_INSTRUCTIONS,
    tools=[sandbox_shell],
    model_settings=ModelSettings(tool_choice="required"),
)Con la tecnología de

Lo importante es:

"type": "container_reference",
"container_id": container.id,Con la tecnología de

Esto le indica a ShellTool que conecte el agente al sandbox que ya creamos, en lugar de crear o usar otro entorno de ejecución distinto.

También establecemos:

tool_choice="required"Con la tecnología de

Esto obliga al agente a usar una herramienta durante la ejecución, en lugar de completar la tarea solo con una respuesta de texto normal.

Para este tutorial, es exactamente lo que queremos. 

El agente no debe limitarse a explicar cómo calcular las métricas financieras. Debe usar la shell, ejecutar código dentro del sandbox y producir los archivos solicitados.

6. Deja que el agente haga el análisis

Con el conjunto de datos subido, el sandbox en marcha y el agente conectado mediante ShellTool, ya podemos iniciar el análisis.

result = await Runner.run(
    analyst,
    "Analyze Northstar entirely inside the sandbox and produce every required artifact.",
    max_turns=30,
)

display(Markdown(result.final_output))Con la tecnología de

Esto pone en marcha el agente analista financiero y le da acceso al sandbox que creamos antes.

La salida final del agente confirma que el análisis se completó correctamente dentro de /mnt/data, incluyendo la validación de datos, la comprobación de métricas y la creación de los seis artefactos requeridos.

7. Descarga los artefactos generados

El análisis ha terminado, pero los archivos generados siguen dentro del sandbox de OpenAI.

Ahora listamos los archivos del contenedor, comprobamos que se crearon todos los artefactos esperados y los descargamos a nuestro directorio local.

remote_files = {
    Path(item.path).name: item
    for item in client.containers.files.list(container.id)
}

missing = [
    name for name in EXPECTED_ARTIFACTS
    if name not in remote_files
]

assert not missing, f"Sandbox did not create: {missing}"

for name in EXPECTED_ARTIFACTS:
    remote = remote_files[name]
    destination = OUTPUT_DIR / name

    client.containers.files.content.retrieve(
        remote.id,
        container_id=container.id,
    ).write_to_file(destination)

    assert destination.stat().st_size > 0, \
        f"Empty artifact: {destination}"

    print(
        f"Downloaded {name}: "
        f"{destination.stat().st_size:,} bytes"
    )Con la tecnología de

Salida:

Downloaded analyze_financials.py: 22,778 bytes
Downloaded calculated_metrics.csv: 3,740 bytes
Downloaded unusual_movements.csv: 25,405 bytes
Downloaded financial_trends.svg: 13,846 bytes
Downloaded investment_analysis.md: 12,159 bytes
Downloaded analysis_run.json: 1,522 bytesCon la tecnología de

Llegados a este punto, puedes abrir el directorio local financial_analysis_output e inspeccionar todo lo que creó el agente.

La carpeta contiene el script de análisis, las métricas calculadas, las alertas de movimientos inusuales, el memo de inversión completo, el manifiesto de validación y una visualización SVG de las tendencias financieras.

El archivo investment_analysis.md contiene el análisis principal por escrito, incluyendo la visión ejecutiva, rentabilidad, liquidez, apalancamiento, flujo de caja, movimientos inusuales y los escenarios optimista y pesimista.

También puedes abrir financial_trends.svg para revisar los resultados visuales. 

Te da una vista rápida de las principales tendencias financieras —ingresos, rentabilidad, márgenes y otras métricas clave— sin tener que leer el informe completo primero.

Un detalle importante: no descargamos sin más cualquier archivo que el agente haya creado. 

El notebook primero compara el contenido del sandbox con EXPECTED_ARTIFACTS.

Si falta alguno de los archivos requeridos, la aserción falla. También comprobamos que cada archivo descargado no esté vacío.

Esto nos da una verificación sencilla antes de aceptar la salida del agente.

8. Limpia el sandbox

Una vez descargados y verificados los archivos, ya no necesitamos el sandbox temporal ni el archivo fuente subido.

Elimina ambos recursos:

client.containers.delete(container.id)
client.files.delete(uploaded_input.id)Con la tecnología de

Esto elimina el contenedor alojado y el conjunto de datos financieros subido tras completar el flujo de trabajo.

Limpiar recursos temporales es un buen paso final, especialmente si creas sandboxes con regularidad como parte del flujo de trabajo del agente.

Reflexiones finales

La mayor ventaja del sandbox alojado por OpenAI es que todo el flujo de trabajo se mantiene dentro de un único ecosistema.

No necesitas conectar un proveedor de sandbox aparte, aprovisionar tu propia nube ni crear y mantener tu propia infraestructura de contenedores. 

Puedes crear un sandbox, adjuntar archivos, controlar el acceso a la red, dejar que el agente trabaje dentro, recuperar los resultados y borrar el entorno cuando termines, todo desde la plataforma de OpenAI.

Eso hace que el flujo sea mucho más fácil de gestionar.

En este tutorial, utilicé el OpenAI Agents SDK con ShellTool porque me permite conectar un agente a un contenedor existente de forma sencilla, manteniendo el control sobre las instrucciones, los archivos, las herramientas y la ejecución.

Hay otras maneras de construir este tipo de flujo dentro del ecosistema de OpenAI, incluidas APIs de agentes más directas y abstracciones de sandbox de mayor nivel. 

Para este ejemplo, sin embargo, el Agents SDK me pareció el equilibrio adecuado entre simplicidad y control.

La idea clave es que ahora puedes darle a un agente de IA un entorno de ejecución real sin salir del ecosistema de OpenAI:

Crear el sandbox → adjuntar los datos → conectar el agente → ejecutar la tarea → recuperar los artefactos → borrar el sandbox.

Para aplicaciones con agentes que necesitan ejecutar código, manipular archivos, generar informes o realizar análisis de varios pasos, es un patrón muy útil.