Daytona
Open source infrastructure that spins up secure, isolated sandboxes in under 90 milliseconds so AI agents can run generated code safely.
Daytona is a secure and elastic infrastructure for running AI generated code. It gives an agent a sandbox, a fully isolated computer with its own kernel, filesystem, network stack, and allocated CPU, memory, and disk, that spins up in under 90 milliseconds and shuts down just as fast. The company started as a development environment manager and pivoted in 2025 to focus on code execution for AI agents, the bottleneck that appears the moment agents stop demoing and start doing real work that involves writing and running code.
Running code an LLM just wrote on your own servers is risky, because the model can hallucinate dangerous operations or be tricked into producing malicious code. Daytona solves this by executing every run inside an isolated sandbox that cannot reach your infrastructure. Just as important, the sandboxes are stateful: agents can snapshot, save, fork, and resume environments across sessions, so a multi step task keeps its context instead of resetting on every retry. That persistence cuts wasted compute and makes long running agent workflows far less fragile.
Agents and developers drive Daytona programmatically through SDKs for Python, TypeScript, Java, and Go, plus a REST API and a CLI, covering sandbox lifecycle, filesystem, and process and code execution. Sandboxes run any code in Python, TypeScript, and JavaScript, are built on OCI and Docker compatibility, and include native Git integration, language server support, Docker in Docker, and even desktop computer use across Linux, macOS, and Windows. There is an official LangChain integration and MCP Server support, and a Declarative Builder for prebaking custom images so sandboxes start even faster.
Daytona is open source with more than 65,000 GitHub stars, so teams can self host on their own infrastructure, and it also offers a managed cloud. Isolation defaults to containers and can be hardened with Kata Containers or gVisor when configured. Pricing is usage based, with $200 of free compute and 5 gigabytes of free storage to start, then per second billing for compute and memory and metered storage beyond the free tier. The company raised a $24M Series A in early 2026 led by FirstMark Capital and runs a startup program with upfront credits.
Vendor details
Canonical URL
https://www.daytona.io
Category
Agent infrastructure
Subcategory
Code execution sandboxes
Funding status
Founded by CEO Ivan Burazin, CTO Vedran Jukic, and Chief Architect Goran Draganic (Burazin previously co-founded Codeanywhere). Raised a $24M Series A in February 2026 led by FirstMark Capital. The open source repo has more than 65,000 GitHub stars. Remains independent.
Company status
independent
Use cases & customers
Primary use cases
Target customers
Deployment options
Integrations
SDKs for Python, TypeScript/JavaScript, Java, and Go, plus a REST API and CLI. Official LangChain integration and MCP Server support, OCI and Docker compatible images, native Git and language server support, and Docker in Docker.
In practice
Your agent writes Python and you need to run it without it touching your servers. You execute each run in an isolated Daytona sandbox, then read the output to validate before showing the user.
Your agent tackles a multi step task that keeps resetting on every retry, wasting compute. You snapshot the sandbox between steps so it resumes with full state instead of rebuilding the environment each time.
You are running reinforcement learning or evaluation jobs that need thousands of environments at once. You spin up Daytona sandboxes in milliseconds and run them concurrently, paying per second only for what executes.
Sources & related URLs
Related / legacy domains
Capability coverage
7.5 / 14 capabilities · 54%
| Integrations & Tool CallingSDKs for Python, TypeScript, Java, and Go, a REST API and CLI, an official LangChain integration, and MCP Server support, serving as an execution tool agents call rather than providing a tool calling layer of its own. | Partial |
|---|---|
| Workflow OrchestrationProvides sandbox lifecycle orchestration (create, configure, snapshot, fork, resume) and massive parallelization, but not agent workflow sequencing, branching, or routing. | Partial |
| Knowledge Grounding & RAGA code execution layer with no retrieval or knowledge grounding capability of its own. | Unable to verify |
| Human Oversight & GuardrailsIsolation contains untrusted code as a hard safety boundary, and human tools provide remote sessions and interfaces to inspect and intervene in sandboxes, but there is no approval workflow or policy engine for agent decisions. | Partial |
| Security, Identity & GovernanceIsolated sandboxes and organizational governance controls are central, but default isolation is container based and stronger isolation (Kata, gVisor) must be configured, and it lacks some enterprise controls such as guaranteed data deletion and dedicated IPs. | Partial |
| Observability & AuditabilityExposes platform level hooks and controls for lifecycle events, but observability and audit of agent behavior are not a first class feature and are typically handled by a paired observability tool. | Unable to verify |
| Memory & State PersistenceCore strength. Stateful environment snapshots, recovery, forking, Volumes, and unlimited persistence let agents save and resume full sandbox state across sessions. | Full |
| Deployment & Data ResidencyOpen source and self hostable on your own infrastructure or on premises, alongside a managed cloud, giving teams control over where AI generated code runs. | Full |
| Prebuilt Agents, Templates & PacksBase images, a Declarative Builder for prebaking custom images, and reusable snapshots speed environment setup, but these are environment templates rather than prebuilt agents. | Partial |
| Triggers & Channel CoverageSandboxes are triggered programmatically through the SDK and API, and system tools expose lifecycle event hooks, but there are no native schedulers or conversational channels. | Partial |
| Model Flexibility & RoutingA compute layer that runs code regardless of which model generated it, with no model selection, routing, or model management features of its own. | Unable to verify |
| APIs, SDKs & MCP ExtensibilityMulti language SDKs (Python, TypeScript, Java, Go), OpenAPI generated REST clients, a CLI, MCP Server support, and a Declarative Builder for custom images. | Full |
| Testing, Debugging & OptimizationProvides the isolated execution and feedback loop (run AI generated code, capture output, retry with error context) that underpins testing and high throughput evaluation pipelines, but it is not an evaluation framework with metrics. | Partial |
| Browser & Computer UseSandboxes include desktop computer use capabilities across Linux, macOS, and Windows, letting agents drive a real desktop environment. | Full |
Pricing
Usage based · $200 free compute + 5 GB storage · open source
Per second compute and memory, plus metered storage
Included quota
$200 in free compute and 5 GB of free storage are included to start. The open source platform is free to self host. Beyond the free tier, compute and memory bill per second and storage is metered.
What is public
Daytona publishes a usage based model: $200 of free compute and 5 GB of free storage to start, then per second billing for compute and memory and metered storage. The platform is also open source and free to self host.
Billing mechanics
Managed sandboxes are metered per second of runtime for compute and memory, with storage metered per gigabyte beyond the free 5 GB. A default 15 minute auto pause keeps a sandbox warm after activity, which can add idle charges unless tuned. GPU sandboxes (for example H100) are billed at a higher hourly rate.
Cost watchouts
Idle time before the default 15 minute auto pause is billable, and concurrency at scale (thousands of sandboxes for RL or evals) can make spend grow quickly. GPU sandboxes cost far more than CPU.
Variable cost rationale
Cost scales directly with sandbox runtime, memory, storage, and concurrency, and these workloads expand fast as teams add more agents, longer sessions, and parallel runs. The 15 minute default auto pause can add idle compute charges.
Additional watchouts
The 15 minute default auto pause can bill idle time between bursts of agent activity. Default isolation uses containers; stronger isolation (Kata, gVisor) must be configured.
Overage / add-ons
After the free credit and storage, compute and memory are billed per second of sandbox runtime and storage is metered per gigabyte. A default 15 minute auto pause means a sandbox can keep billing briefly after activity stops.
Sales call required
No — self-serve available
Free / trial
$200 in free compute and 5 GB free storage; open source is free to self host
Lowest paid plan
Pay as you go usage; no fixed monthly plan
Commercial notes
Open source self hosting gives full control with no platform fee beyond your own infrastructure. The managed cloud trades that for instant scale and sub 100 millisecond sandbox creation. A startup program offers upfront cash and credits.
Key ambiguities
Total cost depends on sandbox runtime, memory size, storage, concurrency, and idle patterns, which are hard to predict before a workload is running.
Cancellation / refund
Self serve, pay as you go usage. No fixed contract for the standard managed plan; self hosting carries no Daytona fee.
Support SLA / resale
Community support for open source and standard usage; enterprise support and governance controls are arranged separately.
Missing data
Daytona's own pricing page emphasizes the free credit and the usage model rather than a full per resource rate card; some exact CPU, memory, storage, and GPU rates come from third party comparisons. Enterprise and governance pricing is not public.
Related vendors
- AgentOps — Agent observability and reliability platform with broad model and…
- Agno — High-performance agent runtime and framework (formerly Phidata) with…
- Apify — Cloud platform for web scraping and automation with 45,000+ prebuilt…
- Arcade — Authenticated tool calling platform and MCP runtime that handles…
- Arize AI — AI observability and evaluation platform that traces, evaluates, and…
- Braintrust — AI evaluation and observability platform with self-serve pricing,…