Code Sandbox

The Code Sandbox is a built-in tool that lets an assistant run real code (Python or JavaScript) instead of just generating text answers. It's especially relevant for tasks the model alone can't reliably handle: exact calculations, processing of Excel/CSV files, file generation.

Why a sandbox?

A language model like GPT or Claude is at its core a text generator: it reads and writes text. Three things it can't reliably do on its own, but that come up constantly in real work:

1. Read binary files: an .xlsx file is not text, it's a binary format. The model only sees what was extracted as text beforehand.
2. Calculate reliably: for larger multiplications or multi-step computations, the model can miscalculate, because it "guesses" numbers based on probability.
3. Complex data analysis: pivots, filters, aggregations across thousands of rows are simply impossible with text processing alone.

The sandbox solves this by giving the model its own small computer. Instead of estimating the answer textually, the model writes Python code that runs on this machine and returns the real result.

How a sandbox call flows

With sandbox vs. without sandbox

What you see in the chat

From a user perspective, this all happens automatically. You see:

• A short loading indicator while the sandbox starts and the code runs (typically seconds, for complex analysis 10–30 seconds)
• Optionally a display of the executed code: depending on the workspace setting
• The result as text in the chat or as a file card with preview and download actions for generated files
• On errors, an error message; the assistant often tries an alternative approach automatically

Security and hosting

The sandbox is an isolated virtual machine: code running inside it has no access to other customer data, the internet, or the MeinGPT system. Even if faulty or malicious code were executed, it could do no damage outside the sandbox.

• Hosting: Frankfurt, Germany (Unikraft Cloud), isolated EU cloud setup
• Lifetime: A sandbox session is bound to your chat. Within the session, files remain in the workspace — across multiple tool calls and messages. When idle, the VM pauses (scale-to-zero); the attached volume keeps the files until the session ends
• Important: The sandbox session is bound to the chat, but not available over long periods. If you keep working in the same chat over multiple days, the session can be automatically terminated in between (e.g. after a longer period of inactivity) — in that case the volume holding the workspace files is also deleted, and your next message starts a new, empty sandbox. There is currently no warning in the chat before this happens. For multi-day projects with intermediate results, we recommend downloading important intermediate files regularly rather than relying on the workspace persisting across multiple days.
• Data flow: Original files are temporarily loaded into the sandbox for processing and deleted immediately after execution. For on-premise customers it's important to note that sandbox processing happens in the cloud
• Internet access: disabled by default
• Script libraries: a broad stack is preinstalled (no pip install needed). Python for data analysis (pandas, numpy, matplotlib, pyarrow), Excel editing and creation (openpyxl, XlsxWriter), PDF (PyMuPDF, pdfplumber, pypdf, PyPDF2, pdfminer.six, pdf2image, reportlab, fpdf2), Office documents (python-docx, python-pptx), web/HTML (requests, beautifulsoup4, lxml, flask), images (Pillow; OCR via pytesseract as a fallback); for Node incl. SheetJS (xlsx), pdfkit, docx, pptxgenjs plus ZIP operations (archiver, unzipper)
• Built-in Office skills: for .xlsx, .docx, and .pptx, MeinGPT ships its own skills — the assistant gets not just the libraries but also the right approach hints (e.g. "preserve formatting when editing, work with styles when generating"). When the sandbox is active in the chat, the AI loads them automatically when a task matches

Current methods

When the Code Sandbox connector is attached to an assistant, the following methods are available. A sandbox session is created implicitly on the first tool call in a chat (matching runtime: Python or Node); there is no separate "start session" method.

• sandbox-write-file: write a chat file into the sandbox
• sandbox-upload-file: upload an external file
• sandbox-download-file: fetch a generated file back into the chat
• sandbox-view-file: let the model look at an image or PDF page from the workspace directly (instead of OCR)
• sandbox-read-file: read a text file from the workspace with line-level offset/limit
• sandbox-execute-command: execute a command inside the sandbox

There is no separate method for skills: MeinGPT provides them in the sandbox automatically (see the next section).

Skills with scripts

Skills that consist of instructions only don't need the sandbox. If a skill contains a scripts/ folder or binary files (e.g. a Word template), the AI runs it in the sandbox:

• Provided automatically: once the AI has loaded such a skill in the chat, it was selected, or it is set to Always on on the assistant, MeinGPT provides it in the session before the next sandbox command – in exactly the version active in the chat, in a folder of its own for each version. After a sandbox restart this happens again.
• Dependencies: packages from a requirements.txt (Python) or package.json (Node) in the skill are installed automatically when it is provided, for that skill only.
• Results: files a script creates land in the sandbox workspace and come back to the chat as a file card.
• Without the sandbox: if the Code Sandbox is turned off in the workspace, the skill library shows Instructions only without sandbox for such skills – the AI then uses only the instructions and doesn't run any scripts.

The AI creates new skills in the chat through the skills tool (e.g. via Create skill → Create with AI in the skill library), independently of the sandbox.

Limits

• Session-bound: The workspace belongs to your chat. If you start a new chat, the sandbox begins fresh — files from another chat aren't available there
• Time limit per execution: A single sandbox command (e.g. via sandbox-execute-command) runs for up to 2 minutes by default, and 5 minutes maximum in any case. If a command isn't done by then, it's cancelled and reported as failed
• Split complex workflows: For very long compute pipelines — like generating a full interactive HTML dashboard from a large Excel file in one step — break the task into smaller steps (prepare data → compute chart data → assemble HTML) instead of one giant call. This also keeps you safely under the per-execution time limit above
• Limited memory: each sandbox VM currently has 1 GB of RAM. Memory-intensive operations on very large tables — such as generating a PDF from a large data table — can fail as a result. If that happens, reduce the data volume first (e.g. filter columns/rows) or split the task into smaller steps
• No outbound internet access from the sandbox: external services are connected via connectors or the Bridge, not directly from code
• Base image ships without curl; the apt-get index is empty until apt-get update: The preinstalled libraries (see Security and hosting) cover the common file workflows; beyond that, the base image is intentionally minimal. curl isn't preinstalled, for example, and the apt-get package index is empty until you explicitly run apt-get update. Larger apt-get install operations can hit the 1 GB RAM limit and leave dpkg in an incomplete state that needs a manual dpkg --configure -a before further installs will work

Frequent questions

Where to go next

• Skills: reusable instructions, optionally with scripts that run in the sandbox
• Assistants: how to attach the Code Sandbox to an assistant as a tool