Direct answer: Build the loop by letting the LLM write Python, running it in an E2B sandbox, appending stdout or tracebacks to the conversation, and repeating until the model stops emitting code — usually 2–4 turns for a CSV question.

What does the loop actually do?

1. Upload the CSV into the sandbox once: sbx.files.write("/data/sales.csv", open("sales.csv","rb").read()).
2. Ask the LLM to write code that answers the question and print results.
3. Execute with sbx.run_code(code).
4. Append the stdout and any error to the message history.
5. Loop while the model keeps emitting code blocks.

How do I feed errors back so it self-corrects?

The trick is to send the real traceback, not a cleaned-up message. Models fix KeyError: 'revenue' far faster than “the code failed.” Include the last 20 lines of stderr and the offending line. Cap retries at three — past that the model usually thrashes.

for turn in range(3):
    code = extract_code(llm(messages))
    result = sbx.run_code(code)
    messages.append({"role":"user","content":
        result.logs.stdout + result.error.traceback if result.error else result.logs.stdout})
    if not result.error and "final" in result.logs.stdout: break

How do I get charts out of the sandbox?

Have the code save a PNG to disk, then pull the bytes: png = sbx.files.read("/chart.png"). Return it as base64 to your front end. Matplotlib works out of the box; for interactive charts, install plotly and write an HTML file instead.

How do I keep runs cheap and fast?

Reuse one sandbox across an entire conversation rather than creating one per turn — that keeps the loaded dataframe in memory and avoids re-uploading the CSV. Set an explicit timeout with Sandbox.create(timeout=600) so a stuck cell doesn’t burn compute. The bigger cost is LLM tokens from verbose outputs, so truncate dataframe prints to the first 50 rows.

What breaks in practice?

Two things bite most people. First, the model assumes libraries that aren’t installed — pin a base template with pandas, numpy, and matplotlib preinstalled to save a round trip. Second, non-deterministic outputs make debugging painful; log every code block and its result so you can replay a failed run.

Is this production-ready?

For internal tools and demos, yes. For customer-facing apps, add a per-user spend cap and a sandbox lifecycle policy — an agent stuck in a loop can quietly rack up sandbox-seconds. E2B’s metering is fine-grained, but your cost controls are your job.

Key Takeaways

• Reuse one sandbox per conversation to keep data in memory.
• Feed full tracebacks back to the LLM; cap self-correction at 3 turns.
• Preinstall pandas, numpy, matplotlib in a base template to avoid install round-trips.
• Pull chart images with sbx.files.read and return them as base64.
• Add spend caps before shipping to customers — loops burn compute fast.

Direct answer: E2B runs each code execution in an isolated Firecracker microVM that boots in about 150ms; you call it through the Python or JS SDK, and the sandbox is destroyed automatically so nothing leaks between runs.

Why not just use a Docker container?

Containers share a kernel, so a determined escape or a fork bomb can still hurt the host. E2B uses Firecracker microVMs with their own kernel, which is a stronger boundary. It also starts faster than a cold container pull and gives each run a clean filesystem by default — no state carried over from the last execution.

How do I get started?

1. Sign up at e2b.dev and copy your API key from the dashboard.
2. Install the SDK: pip install e2b-code-interpreter.
3. Export the key: export E2B_API_KEY=your_key.
4. Run a snippet:

from e2b_code_interpreter import Sandbox
with Sandbox.create() as sbx:
    r = sbx.run_code("import pandas as pd\nprint(pd.__version__)")
    print(r.logs.stdout)

That’s it. The sandbox spins up, runs your code, and tears down when the block exits.

Can I install packages and upload files?

Yes. Call sbx.commands.run("pip install requests") before your code, and push files with sbx.files.write("/data.csv", content). Files are scoped to that one sandbox, so a fresh run starts empty unless you attach a persistent volume.

How much does E2B cost?

The free tier includes $100 of compute credit for new accounts. Paid usage is metered by sandbox-seconds: roughly $0.000014 per second for the 1-vCPU tier, so a 2-minute session is a fraction of a cent. RAM is the bigger lever — a 2GB sandbox costs about double the base rate.

What’s it not good for?

Long-running jobs are a poor fit; sandboxes are meant to be short-lived and the default timeout is 5 minutes, extendable but not indefinitely. There’s no GPU on standard sandboxes, so ML training or heavy inference is off the table. And it’s a US-hosted cloud — if data residency rules say EU-only, you’ll need a different approach.

Who should use E2B?

Teams building code-interpreter features, data-analysis agents, or any product where an LLM writes code that must run. If you only execute your own code, a plain container is simpler and cheaper.

Key Takeaways

• E2B isolates each execution in a Firecracker microVM that boots in ~150ms.
• Default sandbox timeout is 5 minutes and can be extended.
• Free tier gives $100 in compute credit; usage meters at about $0.000014 per sandbox-second.
• No GPU on standard sandboxes — not for training or heavy inference.