A dark bank of metal lockers with rows glowing red, representing a warm pool of ready sandboxes.
Daytona keeps a pool of pre-warmed sandboxes ready, so an agent gets compute in milliseconds instead of seconds.

Daytona is secure, elastic infrastructure for running AI-generated code, repositioned as an agent runtime. It targets a specific pain point: AI agents generate code that must run somewhere safe, and slow sandbox startup breaks the flow of an interactive agent. Daytona reports very fast sandbox creation, “under 90ms from code to execution” in its current documentation (it previously quoted about 27 milliseconds), using pre-warmed pools of sandboxes, and aims at regulated enterprises that need strong isolation with production performance. The company raised a 24 million dollar Series A led by FirstMark Capital, announced on 5 February 2026.

Where it sits in the stack

Daytona sits between your agent and the compute that runs untrusted code. Your agent asks for a sandbox; Daytona hands over one from a warm pool almost instantly, runs the code, and returns the result.

Your agent
LLM Coding agent Data agent Requests compute on demand
Daytona SDK
Python SDK TypeScript SDK Create and drive sandboxes
Sandbox services
Code execution Filesystem Git operations Computer use
Elastic runtime
Pre-warmed pools Isolated sandboxes Sandbox creation under 90 ms

Installation

Daytona provides SDKs for Python and TypeScript (plus Go, Java and Ruby SDKs). Sandboxes are isolated containers by default, with full-VM sandbox classes (Linux and Windows) available for a hardware-virtualization boundary. Install the Python SDK from PyPI.

bash
pip install daytona

For a TypeScript or JavaScript project, install the SDK with npm.

bash
npm install @daytona/sdk

Create an API key in the Daytona dashboard and export it so the SDK can authenticate.

bash
export DAYTONA_API_KEY="your_api_key_here"

Running code in a sandbox

The core pattern configures a client, creates a sandbox, and runs code inside it. This Python example follows the official quickstart.

python
from daytona import Daytona, DaytonaConfig

config = DaytonaConfig(api_key="YOUR_API_KEY")
daytona = Daytona(config)

sandbox = daytona.create()
response = sandbox.process.code_run('print("Hello World")')
print(response.result)

Because each sandbox is a full environment, an agent can run multi-line programs and read structured output. This example computes a result and prints it.

python
from daytona import Daytona, DaytonaConfig

config = DaytonaConfig(api_key="YOUR_API_KEY")
daytona = Daytona(config)

sandbox = daytona.create()

code = """
numbers = [4, 9, 16, 25]
roots = [n ** 0.5 for n in numbers]
print(roots)
"""

response = sandbox.process.code_run(code)
print(response.result)

The SDK also runs raw shell commands through sandbox.process.exec, which suits Git operations, package installs, and file inspection.

python
from daytona import Daytona, DaytonaConfig

config = DaytonaConfig(api_key="YOUR_API_KEY")
daytona = Daytona(config)

sandbox = daytona.create()
response = sandbox.process.exec("echo 'Hello, World!'")
print(response.result)

How a sandbox request flows

The lifecycle of a Daytona sandbox is short. The warm pool is what makes the create step fast enough for interactive agents.

Step 1 Agent requests compute The agent needs to run generated code.
→
Step 2 Claim from pool A pre-warmed sandbox is handed over in under 90 ms (vendor figure).
→
Step 3 Execute Code or commands run inside the isolated sandbox.
→
Step 4 Return result Output goes back to the agent; the sandbox is released.

How it compares

The agent-sandbox market has a handful of serious players. Daytona competes on cold-start speed and its enterprise, regulated-industry positioning. The table compares it with E2B, Modal, and self-managed containers.

DaytonaE2BModalSelf-managed containers
Primary useAgent code executionAgent code executionServerless functionsGeneral workloads
Cold startUnder 90 ms (vendor figure)Sub-secondSub-secondVaries widely
PositioningRegulated enterpriseOpen-source runtimeGPU and batch computeFull control, more work
Open sourceYesYesNoYes
Best forSpeed-sensitive agentsCode interpretersHeavy compute jobsCustom infrastructure

When not to use it

Daytona is not the right choice in every situation.

  • You run trusted code you wrote yourself. Sandbox isolation protects against untrusted, model-generated code. For your own controlled code, standard infrastructure is simpler.
  • You need long-lived services. Sandboxes suit short, disposable tasks. A persistent API or database belongs on a platform built for always-on services.
  • You want the largest open-source community. E2B is an established open-source sandbox runtime with wide adoption. If community size drives your choice, weigh that directly.
  • Your workload is GPU-heavy batch compute. For large-scale training or inference, a compute platform like Modal designed around GPUs fits better than a code sandbox.

Further reading

  • Daytona documentation : official docs, SDK reference, and getting-started guide.
  • Daytona official site : product overview and the case for a fast agent runtime.
  • Daytona on GitHub : the open-source infrastructure for running AI-generated code.
  • E2B : a competing open-source agent sandbox to compare against.
  • Modal : serverless compute for functions, batch jobs, and GPU workloads.
  • What is an AI agent? : the systems that generate the code Daytona runs.

Sources