Computers for Agents

Daytona is the secure and elastic cloud infrastructure built for autonomous agents.

pip install daytona-sdk

from daytona_sdk import Daytona

daytona = Daytona()
sandbox = daytona.create(language="python")
result = sandbox.process.run("print('hello')")
print(result.stdout)

npm install @daytonaio/sdk

import { Daytona } from "@daytonaio/sdk";

const daytona = new Daytona();
const sandbox = await daytona.create({ language: "python" });
const result = await sandbox.process.run("print('hello')");
console.log(result.stdout);

gem install daytona-sdk

require "daytona_sdk"

daytona = Daytona.new
sandbox = daytona.create(language: "python")
result = sandbox.process.run("print('hello')")
puts result.stdout

go get github.com/daytonaio/sdk-go

package main

import daytona "github.com/daytonaio/sdk-go"

func main() {
    d := daytona.New()
    sandbox, _ := d.Create(daytona.CreateOpts{Language: "python"})
    result, _ := sandbox.Process.Run("print('hello')")
    fmt.Println(result.Stdout)
}

dependencies { implementation("io.daytona:sdk-java:0.1.0") }

import io.daytona.sdk.Daytona;
import io.daytona.sdk.Sandbox;
import io.daytona.sdk.model.ExecuteResponse;

public class App {
    public static void main(String[] args) {
        try (Daytona daytona = new Daytona()) {
            Sandbox sandbox = daytona.create();
            ExecuteResponse response = sandbox.process.executeCommand("echo 'Hello, World!'");
            System.out.println(response.getResult());
            sandbox.delete();
        }
    }
}

Start for Free

View Docs

Agents at these companies use Daytona

Agents don't use computers the way people do. Daytona rebuilds the compute layer around how they actually work.

Instant by default

Under 100 ms from API call to running machine — as cheap as calling a function.

Safe to run blind

Code nobody reviewed runs in a sandbox that contains it — not your infrastructure, data, or users.

Free while stopped

Per-second billing, only while running. Stopped sandboxes keep their state and cost next to nothing.

Machine Speed Infrastructure

Sub-100ms environment creation means zero bottlenecks between agent reasoning and execution, enabling real-time autonomous workflows that compound at machine speed.

Get Started

Machine Speed Infrastructure

Sub-100ms environment creation means zero bottlenecks between agent reasoning and execution, enabling real-time autonomous workflows that compound at machine speed.

Get Started

Full Spectrum Composability

From headless containers to full desktop environments, Daytona provides complete computing flexibility. Your agents can execute code, browse the web, manipulate files, and use any tool—across Linux, Windows, or macOS—all through the same unified infrastructure.

Computer Use

Full Spectrum Composability

Computer Use

Instantaneous Elasticity

Massive parallelization without infrastructure complexity. Spin up isolated agent workloads on-demand with complete isolation, secure credential handling, and the same sub-100ms performance—whether you're running one agent or orchestrating thousands.

Snapshots

Instantaneous Elasticity

Snapshots

Tail Error Rates at Scale

Run a million trajectories and a 0.1% failure rate breaks 1,000 of them. Daytona holds a 0% error rate out to P99.99 of sandbox starts.

Improving Agent Performance

Daytona sandboxes cold-start in 162ms — up to 110× faster than cloud VMs. Over a million trajectories, that's a 5,316 worker-hour gap. Read the paper

Agent Native Architecture

Sandboxes

Fork a running sandbox — filesystem and memory — into a fully independent copy. Branch an agent's world mid-run and test different paths in parallel.

Programmatic Sandbox Control

The whole machine is a typed API. Agents run processes, edit files, drive git, query language servers, and open real terminals — and a human can step in over SSH at any moment.

Docs

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Run a one-shot command and capture its output
result = sandbox.process.exec("python -c 'print(2 ** 16)'")
print(result.stdout)  # 65536

# Stream long-running output line by line
for line in sandbox.process.stream("pytest -q"):
    print(line)

sandbox.delete()

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Write, read, and search files inside the sandbox
sandbox.fs.write_file("/work/notes.md", "# Hello from Daytona")
contents = sandbox.fs.read_file("/work/notes.md")

matches = sandbox.fs.find_files("/work", "TODO")
sandbox.fs.replace_in_files(
    [m.file for m in matches],
    "TODO",
    "DONE",
)

sandbox.delete()

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Clone, branch, commit, push — all from the SDK
repo = sandbox.git.clone(
    "https://github.com/daytonaio/example.git",
    path="/work/example",
)
sandbox.git.checkout(repo, "feature/agent-edit", create=True)
sandbox.fs.write_file("/work/example/AGENT.md", "Edited by an agent.")
sandbox.git.add(repo, ["AGENT.md"])
sandbox.git.commit(repo, "Add AGENT.md")
sandbox.git.push(repo)

sandbox.delete()

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Start a language server and ask it about the code
lsp = sandbox.create_lsp_server("typescript", "/work/app")
lsp.start()
lsp.did_open("/work/app/src/index.ts")

symbols = lsp.document_symbols("/work/app/src/index.ts")
for s in symbols:
    print(f"{s.kind}: {s.name}")

diagnostics = lsp.diagnostics("/work/app/src/index.ts")
print(diagnostics)

sandbox.delete()

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Open a pseudo-terminal — full interactive shell, ANSI-aware
pty = sandbox.process.create_terminal(cols=120, rows=32)
pty.send("export NODE_ENV=development\n")
pty.send("npm run dev\n")

for chunk in pty.stream():
    print(chunk, end="")
    if "ready - started server" in chunk:
        break

pty.close()
sandbox.delete()

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Mint SSH access so a human can step in
ssh = sandbox.create_ssh_access()
print(ssh.command)  # ssh <token>@ssh.app.daytona.io

# Works with any SSH client — including VS Code Remote

# Or hand over a browser-based web terminal
terminal = sandbox.get_preview_link(22222)
print(terminal.url)

sandbox.delete()

Process Execution

1/6

Run one-shot commands or stream long-lived processes — every invocation lands inside an isolated, elastic sandbox.

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Run a one-shot command and capture its output
result = sandbox.process.exec("python -c 'print(2 ** 16)'")
print(result.stdout)  # 65536

# Stream long-running output line by line
for line in sandbox.process.stream("pytest -q"):
    print(line)

sandbox.delete()

Read, write, search, and rewrite files via a typed API — no shell quoting required.

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Write, read, and search files inside the sandbox
sandbox.fs.write_file("/work/notes.md", "# Hello from Daytona")
contents = sandbox.fs.read_file("/work/notes.md")

matches = sandbox.fs.find_files("/work", "TODO")
sandbox.fs.replace_in_files(
    [m.file for m in matches],
    "TODO",
    "DONE",
)

sandbox.delete()

Clone, branch, commit, and push through the SDK — agents can author full pull requests without spawning git themselves.

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Clone, branch, commit, push — all from the SDK
repo = sandbox.git.clone(
    "https://github.com/daytonaio/example.git",
    path="/work/example",
)
sandbox.git.checkout(repo, "feature/agent-edit", create=True)
sandbox.fs.write_file("/work/example/AGENT.md", "Edited by an agent.")
sandbox.git.add(repo, ["AGENT.md"])
sandbox.git.commit(repo, "Add AGENT.md")
sandbox.git.push(repo)

sandbox.delete()

Spin up a language server inside the sandbox to surface symbols, diagnostics, and refactors back to the agent.

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Start a language server and ask it about the code
lsp = sandbox.create_lsp_server("typescript", "/work/app")
lsp.start()
lsp.did_open("/work/app/src/index.ts")

symbols = lsp.document_symbols("/work/app/src/index.ts")
for s in symbols:
    print(f"{s.kind}: {s.name}")

diagnostics = lsp.diagnostics("/work/app/src/index.ts")
print(diagnostics)

sandbox.delete()

Open a real ANSI-aware terminal for interactive tools — REPLs, watchers, dev servers — that need a TTY.

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Open a pseudo-terminal — full interactive shell, ANSI-aware
pty = sandbox.process.create_terminal(cols=120, rows=32)
pty.send("export NODE_ENV=development\n")
pty.send("npm run dev\n")

for chunk in pty.stream():
    print(chunk, end="")
    if "ready - started server" in chunk:
        break

pty.close()
sandbox.delete()

Every sandbox is one command away from a human: SSH in, attach VS Code, or open a web terminal in the browser. Inspect what the agent did, fix it, and hand control back.

from daytona import Daytona

daytona = Daytona()
sandbox = daytona.create()

# Mint SSH access so a human can step in
ssh = sandbox.create_ssh_access()
print(ssh.command)  # ssh <token>@ssh.app.daytona.io

# Works with any SSH client — including VS Code Remote

# Or hand over a browser-based web terminal
terminal = sandbox.get_preview_link(22222)
print(terminal.url)

sandbox.delete()

Case Studies

“If anybody asked me which runtime platform to use, I'm going to 100% say Daytona every time. With their SDK, we never have to worry about an agent leaking or taking actions that it shouldn't.”

Brace SproulHead of Applied AI, LangChain

Sandboxes created per month with Daytona

Hours of sandbox runtime per month

Minute agent sessions fully supported

Read Case Study

All Case Studies

0B+

Code Executions

0M+

Code Executions

0M+

Agents Launched

Every agent workload. One compute layer.

Pick a workload and start from a working example. Every solution links to a step-by-step guide — real code on real infrastructure, ready to ship.

See Guides

Built for autonomy. Certified for the enterprise.

Every sandbox runs on dedicated, isolated infrastructure — no shared compute, no cross-tenant risk. SOC 2, GDPR, HIPAA, SSO, and audit logs come standard. And with BYOC, Daytona runs in your own cloud.

Talk to Our Team

FAQ

Extra questions about the how and the why? Reach out on our community channel and we’ll happily expand.

Talk to Our Team

Computers for Agents

Agents don't use computers the way people do. Daytona rebuilds the compute layer around how they actually work.

Instant by default

Safe to run blind

Free while stopped

Machine Speed Infrastructure

Machine Speed Infrastructure

Full Spectrum Composability

Full Spectrum Composability

Instantaneous Elasticity

Instantaneous Elasticity

Tail Error Rates at Scale

Improving Agent Performance

Agent Native Architecture

Programmatic Sandbox Control

Case Studies

Every agent workload. One compute layer.

Coding Agents

AI Evaluations

Reinforcement Learning

Computer Use

Code Interpreter

Data Analysis

Model Serving

Always-on Assistants

Autonomous Bug Fixing

Built for autonomy. Certified for the enterprise.

FAQ

Run AI Code

Computers for Agents

Agents don't use computers the way people do. Daytona rebuilds the compute layer around how they actually work.

Instant by default

Safe to run blind

Free while stopped

Machine Speed Infrastructure

Machine Speed Infrastructure

Full Spectrum Composability

Full Spectrum Composability

Instantaneous Elasticity

Instantaneous Elasticity

Tail Error Rates at Scale

Improving Agent Performance

Agent Native Architecture

Programmatic Sandbox Control

Case Studies

Every agent workload. One compute layer.

Coding Agents

AI Evaluations

Reinforcement Learning

Computer Use

Code Interpreter

Data Analysis

Model Serving

Always-on Assistants

Autonomous Bug Fixing

Built for autonomy. Certified for the enterprise.

FAQ

What is Daytona and how does it enable AI?

How does Daytona ensure the safe execution of AI-generated code?

What are AI Sandboxes and how do they enhance agentic AI workflows?

How can I integrate Daytona into my existing development stack?

What security measures does Daytona implement for AI development?

How does Daytona support the development and deployment of AI agents?

Run AI Code