Daytona
Service domainCODE SANDBOX
Arcade Optimized
Arcade tools designed for LLMs to interact with Daytona sandboxes
46tools
46require secrets
Arcade's Daytona toolkit lets LLMs create, manage, and interact with Daytona cloud sandboxes — running code, executing shell commands, managing files, working with Git, and controlling sandbox lifecycle.
Capabilities
- Sandbox lifecycle & resources — create (from snapshot or Docker image), start, stop, archive, delete, scale CPU/memory/disk, update auto-stop/archive/delete policies, label and filter sandboxes, list regions, and generate SSH access credentials.
- Code & command execution — run code directly in a sandbox (no shell escaping), execute shell commands, and manage persistent background sessions for long-running processes (dev servers, watchers) with async command support, log retrieval, and interactive input.
- File system operations — read, write, move, delete, create folders, get metadata, search by filename glob, search file contents with grep/regex, and replace text across multiple files.
- Git & repository management — clone repos, check out/create/delete branches, stage files, commit, pull, push, view status, list commits, and list branches; GitHub auth is handled automatically via Arcade OAuth for clone/pull/push.
- Snapshot & port management — create and inspect sandbox snapshots (image templates), list available snapshots, list active ports, and retrieve preview URLs (standard or signed) for web services running inside a sandbox.
- Introspection & identity — get detailed sandbox info (state, resources, labels, timestamps, redacted env vars), list sandboxes/sessions/snapshots with pagination, and confirm API key identity via
WhoAmI.
OAuth
This toolkit uses GitHub OAuth2 for user authorization (e.g., authenticating Git operations against GitHub repositories). See the Arcade GitHub auth provider docs for setup details.
Secrets
DAYTONA_API_KEY — A Daytona API key that authenticates all SDK calls to the Daytona platform (sandbox CRUD, file I/O, session management, snapshots, etc.). To obtain one: log in to the Daytona dashboard, navigate to Settings → API Keys, and generate a new key. The key is shown once at creation; copy and store it immediately. No specific scope selection is exposed in the UI — the key grants access to all resources owned by your account. Store it as a secret in Arcade rather than embedding it in tool calls.
See the Arcade secrets guide for how to register secrets, or manage them directly at https://api.arcade.dev/dashboard/auth/secrets.
Available tools(46)
46 of 46 tools
Operations
Behavior
| Tool name | Description | Secrets | |
|---|---|---|---|
Archive a stopped sandbox to reduce storage costs.
The sandbox must be stopped first. Can be started again later, though
startup takes longer than from stopped state. | 1 | ||
Switch to a branch, tag, or commit. Optionally create a new branch.
Default mode (create_new_branch=False): switches to an existing ref.
Create mode (create_new_branch=True): creates a new branch named ref
and switches to it, optionally from start_point. | 1 | ||
Clone a Git repository into the sandbox.
For GitHub repos, authentication is handled automatically via Arcade's
OAuth integration — the user is prompted to authorize once, and the
token is managed by Arcade Engine. Consent is one-time; token refresh
is automatic.
Permission requirements by auth mode:
- OAuth Apps mode: the "repo" scope is requested (full repo access).
- GitHub Apps mode: the app installation must have "Contents: read"
permission (for clone/pull) or "Contents: read & write" (for
clone followed by push).
For non-GitHub private repos, provide username + PAT as overrides. | 1 | ||
Commit staged changes. Files must be staged before committing. | 1 | ||
Create a new branch and switch to it.
Equivalent to `git checkout -b <branch> [start_point]`. | 1 | ||
Create a folder (with parent directories) in the sandbox. | 1 | ||
Create a new isolated sandbox for code execution.
Two creation modes: from a Daytona snapshot or from a Docker image.
If neither snapshot nor image is specified, uses the standard base image.
Resource params (cpu, memory_gb, disk_gb, gpu) only apply to image-based creation.
Returns sandbox name, ID, and status. The sandbox is ready to run code and commands
immediately.
Note: A ``region`` parameter is deferred -- the Daytona SDK's
``CreateSandboxFromImageParams`` / ``CreateSandboxFromSnapshotParams`` do not
currently expose a ``target``/``region`` field. | 1 | ||
Create a persistent background session for long-running processes.
Sessions persist across tool calls -- useful for dev servers, watchers, or
multi-step workflows where you need to run commands sequentially. | 1 | ||
Create a new sandbox snapshot (image template).
Snapshots define the base environment for new sandboxes.
The image parameter is required -- it specifies the base Docker image.
Building the image can take several minutes. The tool waits up to 50 seconds; a build
that runs longer keeps going, so check the snapshot's state before creating it again. | 1 | ||
Create SSH access credentials for the sandbox.
Returns connection details including host, port, username, and access token
for direct SSH access. Use the token to authenticate SSH connections.
SENSITIVE OUTPUT: The returned token grants SSH access to the sandbox.
Avoid logging or displaying it in contexts where it could be inadvertently
exposed. The token expires after ``expires_in_minutes`` (default 60 min).
Set ``expires_in_minutes=0`` to create a non-expiring token (use with
caution -- increases blast radius from accidental exposure). | 1 | ||
Delete a local branch. | 1 | ||
Delete a file or empty directory. Set recursive=True to delete non-empty directories. | 1 | ||
Permanently delete a sandbox and all its contents. | 1 | ||
Read file contents from the sandbox.
For large files, use start_line and end_line to read specific sections.
Omit both to read the entire file.
Known limitation: the full file is downloaded before line-range slicing is
applied. For very large files this may be slow. The Daytona SDK does not
currently expose range/chunk reads. | 1 | ||
Get metadata about a file: size, permissions, modified time, type. | 1 | ||
Get a preview URL for a web service running in the sandbox.
Standard URLs require an auth token in the x-daytona-preview-token header.
Signed URLs embed authentication in the URL itself -- useful for sharing. | 1 | ||
Get repository status: branch, staged/modified/untracked files, ahead/behind counts. | 1 | ||
Get detailed information about a sandbox.
Returns state, resources, labels, auto-stop/archive settings, and timestamps.
Environment variable values whose keys look secret-like (containing token,
key, secret, password, auth) are redacted by default. Set
include_raw_env_vars=True only when you need the actual values. | 1 | ||
Get output logs from a command running in a session.
Useful for checking output of async commands (servers, builds). | 1 | ||
Get detailed information about a snapshot.
Accepts a snapshot name or ID. Returns full details including state,
image, resources, entrypoint, and timestamps. | 1 | ||
List all branches. Indicates which branch is currently checked out. | 1 | ||
Get commit history. Returns commit hash, author, date, and message. | 1 | ||
List files and directories. Returns name, type (file/dir), and size.
Response includes total count and has_more flag for pagination. | 1 | ||
List active ports in the sandbox.
Returns port number, state, and name for each active port.
Use this to discover running services before requesting a port's preview URL. | 1 | ||
List available regions for sandbox creation.
Returns region ID, name, and location (country, city).
Useful for choosing where to create sandboxes or snapshots. | 1 |
Page 1 of 2(25 of 46)
Last updated on