Skip to main content

​
Overview

Every chat thread runs in its own isolated sandbox. When you send a message, the agent has access to a full Linux environment where it can install packages, write files, run code, and execute commands. This sandbox persists between messages within the same thread.
This is a Pro feature. Your sandbox automatically pauses when idle and resumes instantly when you return.

​
How persistence works

When you send a message in a chat thread, the agent’s sandbox is in one of three states:
The sandbox is live and ready. Your previous messages’ context (installed packages, files, running processes) are all available. This is the fastest state — the agent can start working immediately.When this happens: You’re actively chatting or recently sent a message.
After 30 minutes of inactivity, the sandbox automatically pauses. Everything is saved — files, packages, memory, running processes. Nothing is lost.When this happens: You step away from a thread for more than 30 minutes.
If the saved sandbox is no longer available, a new one is created. Your conversation history is preserved, but installed packages and files from previous messages need to be re-created.When this happens: Very old threads or after extended periods of inactivity.

​
What this means for you

​
Packages persist between messages

If you ask the agent to install pandas in your first message, it’s still available in your second, third, and hundredth message — as long as you’re in the same thread. 
You: Install pandas and matplotlib
Agent: Done! Both packages are installed.

You: Now create a chart of Apple's stock price
Agent: [uses pandas and matplotlib without reinstalling]

​
Files persist between messages

Files created by the agent stay on disk. You can reference them in later messages: 
You: Download the sales data and save it as sales.csv
Agent: Saved to sales.csv

You: Now analyze sales.csv and create a summary report
Agent: [reads the previously saved file]

​
Resuming is fast

When you return to a paused sandbox, it resumes in about one second. You won’t notice any delay — the agent picks up right where you left off.

​
Thread isolation

Each chat thread has its own sandbox. Work done in one thread doesn’t affect another:
  • Thread A installs pandas → only Thread A has pandas
  • Thread B is completely independent with its own packages and files
  • Deleting a thread cleans up its sandbox
If you need the same environment across multiple tasks, create an agent from your configured thread. The agent captures the full sandbox environment and reuses it for every run.

​
When is a fresh sandbox created?

A new sandbox is created when:
  • You start a new chat thread
  • The previous sandbox is no longer available (rare, usually after extended inactivity)
Agent runs are different — each run creates a sandbox from the agent’s saved environment snapshot (see Agent Runtime Environment). This means the sandbox comes pre-loaded with all the packages and configuration from when the agent was created or last updated, rather than starting from a blank slate. In all cases, the agent has access to your conversation history, so it can understand context from previous messages even in a fresh sandbox.

​
Best practices

Keep related work in one thread

Packages and files persist within a thread. Keep related tasks together to avoid re-installing.

Save reusable setups as agents

If you spend time configuring an environment, save it as an agent so you don’t repeat the setup.

Use workspaces for organization

Group related threads in a workspace. Each thread still has its own sandbox, but workspaces help you stay organized.

Reference files by path

The agent remembers file paths between messages. Reference them directly for efficient follow-ups.