Build a Data-Analysis Agent That Runs Pandas in a Sandbox

python3 -m venv .venv && . .venv/bin/activate
pip install sandboxer-sdk
export SANDBOXER_API_KEY=sbx_live_…

import csv, random
from datetime import date, timedelta

random.seed(7)
regions = {"North": 1.00, "South": 0.85, "East": 1.10, "West": 0.95}
growth = {"North": 0.010, "South": 0.035, "East": 0.005, "West": 0.020}  # monthly
products = {"Starter": 19.0, "Team": 49.0, "Business": 129.0}
with open("sales.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["order_id", "date", "region", "product", "units", "unit_price"])
    oid = 10000
    d = date(2026, 1, 1)
    while d <= date(2026, 9, 30):
        m = d.month - 1
        for region, base in regions.items():
            for _ in range(random.randint(1, 3)):
                product = random.choices(list(products), weights=[5, 3, 1])[0]
                units = max(1, int(random.gauss(4, 2) * base * (1 + growth[region]) ** m))
                oid += 1
                w.writerow([oid, d.isoformat(), region, product, units, products[product]])
        d += timedelta(days=1)

$ python3 make_data.py && wc -l sales.csv && head -3 sales.csv
2187 sales.csv
order_id,date,region,product,units,unit_price
10001,2026-01-01,North,Business,3,129.0
10002,2026-01-01,North,Team,4,49.0

import json
import struct
import sys
import time
from pathlib import Path

from sandboxer import Sandboxer

client = Sandboxer()  # reads SANDBOXER_API_KEY
PY = "/home/user/.venv/bin/python"  # the sandbox's analysis venv


def open_workspace(name: str):
    """Create a sandbox and install the analysis stack once."""
    sandbox = client.create(type="small", ttl_seconds=1800, name=name)
    t = time.time()
    sandbox.exec(
        "uv venv -q ~/.venv && uv pip install -q --python ~/.venv pandas matplotlib",
        timeout_seconds=300,
        check=True,
    )
    print(f"installed pandas + matplotlib in {time.time() - t:.1f}s")
    return sandbox


def png_size(data: bytes):
    """Width and height from a PNG header."""
    return struct.unpack(">II", data[16:24])


def run_analysis(sandbox, code: str) -> dict:
    """Tool for the agent: run Python (pandas, matplotlib) in the sandbox.
    The dataset is at data/sales.csv. Save charts to out/*.png.
    Returns stdout, stderr, exit code and the charts it saved."""
    sandbox.exec("mkdir -p out && rm -f out/*.png")
    sandbox.files.write("analysis.py", code)
    r = sandbox.exec(f"MPLBACKEND=Agg {PY} analysis.py", timeout_seconds=120)
    charts = []
    listing = sandbox.exec("ls out/*.png 2>/dev/null").stdout.split()
    for path in listing:
        data = sandbox.files.read_bytes(path)  # up to 5 MiB
        Path(path).parent.mkdir(exist_ok=True)
        Path(path).write_bytes(data)
        w, h = png_size(data)
        charts.append({"path": path, "bytes": len(data), "width": w, "height": h})
    return {
        "exit_code": r.exit_code,
        "stdout": r.stdout[-4000:],  # keep the model's context small
        "stderr": r.stderr[-2000:],
        "charts": charts,
    }


# The code a model would write for "Which region grew the most, and show me a chart".
ANALYSIS = r'''
import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("data/sales.csv", parse_dates=["date"])
df["revenue"] = df["units"] * df["unit_price"]
monthly = (df.groupby([df["date"].dt.to_period("M"), "region"])["revenue"]
             .sum().unstack())
q1 = monthly.loc["2026-01":"2026-03"].sum()
q3 = monthly.loc["2026-07":"2026-09"].sum()
summary = pd.DataFrame({
    "orders": df.groupby("region").size(),
    "revenue": df.groupby("region")["revenue"].sum().round(0).astype(int),
    "q1_rev": q1.round(0).astype(int),
    "q3_rev": q3.round(0).astype(int),
    "q3_vs_q1": ((q3 / q1 - 1) * 100).round(1).astype(str) + "%",
}).sort_values("q3_rev", ascending=False)
print(f"{len(df)} orders, {df['date'].min():%Y-%m-%d} to {df['date'].max():%Y-%m-%d}")
print(summary.to_string())

ax = monthly.plot(figsize=(8, 4.5), marker="o")
ax.set_title("Monthly revenue by region, 2026")
ax.set_xlabel("")
ax.set_ylabel("Revenue (USD)")
plt.tight_layout()
plt.savefig("out/revenue_by_region.png", dpi=120)
'''

if __name__ == "__main__":
    sandbox = open_workspace(sys.argv[1] if len(sys.argv) > 1 else "aeo-data-1")
    print("sandbox", sandbox.id)
    try:
        sandbox.exec("mkdir -p data")
        sandbox.files.write("data/sales.csv", Path("sales.csv").read_bytes())
        print("uploaded", sandbox.exec("wc -c < data/sales.csv").stdout.strip(), "bytes")

        t = time.time()
        result = run_analysis(sandbox, ANALYSIS)
        print(f"--- call 1 ({time.time() - t:.1f}s)")
        print(json.dumps(result, indent=2))

        # A follow-up question reuses the same sandbox: no reinstall, the CSV is still there.
        t = time.time()
        result = run_analysis(sandbox, r'''
import pandas as pd
df = pd.read_csv("data/sales.csv")
df["revenue"] = df["units"] * df["unit_price"]
print(df.pivot_table(index="region", columns="product", values="revenue", aggfunc="sum").round(0).astype(int).to_string())
''')
        print(f"--- call 2 ({time.time() - t:.1f}s)")
        print(json.dumps(result, indent=2))
    finally:
        sandbox.delete()
        print("deleted", sandbox.id)