Daytona
Daytona is a development environment management platform that provides cloud-based development workspaces with API access for automation
Verdict
Common use cases
- Spin up isolated test environments on demand
- Clone repos into sandboxes for code review
- Onboard contractors without local setup friction
- Debug flaky tests in clean ephemeral containers
- Verify sandbox access before sharing with teammates
Integration
- Vendor
- Daytona
- Category
- developer-tools
- Auth
- API_KEY
- Tools
- 50
- Composio slug
daytona
Tools
- Archive Sandbox
Archives a sandbox in the Daytona platform. Use this action when you need to archive a sandbox that is no longer needed but should be preserved for future reference. The sandbox will be marked as archived and its state will change to reflec
- Cancel Organization Invitation
Cancels a pending organization invitation. Use when you need to revoke an invitation that has been sent but not yet accepted by the recipient. This action is irreversible — once an invitation is cancelled, it cannot be reactivated and the r
- Checkout Git Branch
[DEPRECATED] Checkout a branch or commit in a git repository within a sandbox. Use this action when you need to switch branches or checkout a specific commit in a git repository that exists within a sandbox toolbox. This operation modifies
- Check Sandbox Access
Checks if the authenticated user has access to a specific sandbox. Use this action when you need to verify whether the current user has permission to access a particular sandbox before performing further operations on it. This is a read-onl
- Clone Repository
Clones a Git repository into a sandbox toolbox. Use this action when you need to clone a public or private Git repository into a specific directory within a sandbox. Supports optional branch selection and commit checkout. This is commonly u
- Create API Key
Creates a new API key for the organization. Use when you need to generate a new API key that can be used to authenticate API requests. The created API key value is only returned once in the response and cannot be retrieved again, so it must
- Create Docker Registry
Creates a new Docker registry for the organization. Use when you need to register a new container registry (such as Docker Hub, GCR, ECR, or other Docker registries) so that Daytona can pull images from it. The registry credentials are stor
- Create Folder in Sandbox
Creates a new folder inside a sandbox's filesystem. Use this action when you need to create a directory within a running sandbox's filesystem. This is useful for organizing files, preparing directory structures, or setting up paths for subs
- Create Organization
Creates a new organization in Daytona. Use this action when you need to set up a new organization with a specific name and default region configuration. This action creates a top-level organization entity that can manage sandboxes, users, a
- Create Organization Invitation
Creates an invitation to join an organization with specified roles and permissions. The invitation will be sent to the provided email address. Use this action when you need to invite a new member to an organization with specific role assign
- Create Organization Role
Creates a new organization role with specified permissions. Use this action when you need to define custom roles for organization members, allowing fine-grained control over what resources they can access and what operations they can perfor
- Create Process Session
Creates a new session in the sandbox for process management. Use this action when you need to establish a new process session within a running sandbox environment. This enables managing process execution and state within the Daytona platfor
- Create PTY Session
Creates a new PTY (pseudo-terminal) session in a sandbox. Use this action when you need to establish an interactive terminal session within a running sandbox environment. This enables real-time command execution and terminal interaction thr
- Create Sandbox
Creates a new sandbox environment for development or testing purposes. Use this action when you need to provision a new isolated environment with configurable compute resources (CPU, memory, GPU), networking options, and storage volumes. Th
- Create Sandbox Backup
Initiates a backup operation for an existing sandbox environment. Use this action when you need to create a point-in-time snapshot of a sandbox that can be used for restoration or cloning purposes. The backup operation is asynchronous and t
- Create Snapshot
Creates a new snapshot resource that can be used as a base image for sandboxes. Use this action when you need to create a new snapshot with specific compute resources (CPU, memory, GPU, disk) and a container image. Snapshots define the base
- Create SSH Access
Creates SSH access credentials for a sandbox environment. Use this action when you need to establish an SSH connection to a sandbox for administrative tasks, file transfers, or development operations. The returned credentials include a toke
- Create Volume
Creates a new volume for storing data that can be attached to sandboxes. Use this action when you need to provision persistent storage for your sandbox environments. Volumes persist data across sandbox restarts and can be mounted to sandbox
- Deactivate Snapshot
Deactivates a snapshot in the Daytona platform. Use this action when you need to deactivate a snapshot that is currently active. This will stop the snapshot from being used for new sandbox creations. Note: Deactivating a snapshot does not d
- Delete API Keydestructive
Deletes an API key by its name. Use when you need to revoke access for an API key that is no longer needed or has been compromised. This action is irreversible — once an API key is deleted, it cannot be recovered and any systems using that
- Delete API Key for Userdestructive
Deletes an API key for a specific user. Use when you need to remove an existing API key associated with a user account, such as when cleaning up unused credentials or revoking access. This action is irreversible — once the API key is delete
- Delete Docker Registrydestructive
Deletes a Docker registry from the Daytona platform. Use when you need to remove an existing Docker registry configuration. This is an irreversible operation — once a registry is deleted, it cannot be recovered and any references to it in w
- Delete Git Branchdestructive
Deletes a branch from a git repository inside a sandbox by its name. Use when you need to permanently remove a git branch that is no longer needed. This action is irreversible — once a branch is deleted, it cannot be recovered unless it has
- Delete Organizationdestructive
Deletes an organization. Use when you need to permanently remove an organization from the system, including all associated data, members, and resources. This action is irreversible — once an organization is deleted, it cannot be recovered.
- Delete Organization OTEL Configdestructive
Deletes the OpenTelemetry (OTEL) configuration for an organization. Use this action when you need to remove the OpenTelemetry settings that were previously configured for an organization's observability and tracing capabilities. This action
- Delete Organization Roledestructive
Deletes an organization role. Use when you need to permanently remove a role from an organization, such as cleaning up unused custom roles or removing roles that are no longer needed. This action is irreversible — once a role is deleted, it
- Delete PTY Sessiondestructive
Deletes a PTY session and terminates the associated process. Use this action when you need to clean up an active PTY session that is no longer needed. This will terminate any process running in that session and release the associated resour
- Delete Recordingdestructive
Deletes a recording from the Daytona platform by its ID. Use when you need to permanently remove a recording that is no longer needed. This action is irreversible — once a recording is deleted, it cannot be recovered. Any data associated wi
- Delete Sandboxdestructive
Deletes a sandbox from the Daytona platform by its ID or name. Use when you need to permanently remove a sandbox that is no longer needed. This action is irreversible — once a sandbox is deleted, it cannot be recovered. Any data, processes,
- Delete Sandbox Filedestructive
Deletes a file inside a sandbox by its path. Use when you need to permanently remove a file from a sandbox that is no longer needed. This action is irreversible — once a file is deleted, it cannot be recovered. Ensure the file is not needed
- Delete Sessiondestructive
Deletes a session from the Daytona platform by its ID. Use when you need to permanently remove a session that is no longer needed. This action is irreversible — once a session is deleted, it cannot be recovered. Any ongoing processes or dat
- Delete Snapshotdestructive
Deletes a snapshot from the Daytona platform by its ID. Use when you need to permanently remove a snapshot that is no longer needed. This action is irreversible — once a snapshot is deleted, it cannot be recovered. Any data stored in the sn
- Delete Volumedestructive
Deletes a volume from the Daytona platform by its ID. Use when you need to permanently remove a volume that is no longer needed. This action is irreversible — once a volume is deleted, it cannot be recovered. Ensure all important data has b
- Download File (Deprecated)
[DEPRECATED] Downloads a file from a sandbox's toolbox filesystem. Use this action when you need to retrieve a file from the sandbox's toolbox. Note: This endpoint is deprecated. Consider using an alternative if available. This is a read-on
- Download Multiple Files
Downloads multiple files from a sandbox as a multipart/form-data bundle. Use this action when you need to retrieve multiple files from a sandbox in a single operation. The files are returned as a streamed multipart response where each file
- Enroll in SMS MFA
Enrolls the authenticated user in SMS-based multi-factor authentication. Use when you need to enable SMS-based MFA for the authenticated user account. This action initiates the enrollment process and returns a URL where the user can complet
- Execute Command
Executes a shell command within a running sandbox via the toolbox proxy. Use this action when you need to run shell commands, scripts, or any executable commands inside a sandbox environment. This is useful for automation tasks, running bui
- Expire Signed Port Preview URL
Expires a signed preview URL for a sandbox port. Use this action when you need to immediately invalidate a signed preview URL for a specific port on a sandbox, revoking access for anyone holding the token. This action is useful for security
- Find In Files (Deprecated)
[DEPRECATED] Searches for text or patterns in files within a sandbox. Use this action when you need to find occurrences of a specific text or pattern across files in a sandbox. This is useful for code search, debugging, or locating specific
- Focus Accessibility Node
Focuses an accessibility node in a sandbox's computer use system. Use this action when you need to programmatically set focus to a specific accessibility node within a sandbox's desktop environment. This is particularly useful for UI automa
- Get API Key
Retrieves an API key by its name. Use when you need to retrieve details about a specific API key, including its creation date, expiration, permissions, and usage statistics. This is a read-only operation that does not modify any resources.
- Get Available Account Providers
Retrieves all available account providers that can be used to authenticate and link accounts. Use when you need to discover which account providers (such as GitHub, GitLab, Google) are available for linking to the user's account. This is a
- Get Build Logs URL
Retrieves the build logs URL for a specific sandbox by its ID or name. Use this action when you need to access build logs for a sandbox, such as during troubleshooting build failures, monitoring build progress, or retrieving historical buil
- Get Commit History
Gets commit history from a repository in a sandbox toolbox. Use this action when you need to retrieve the commit history including: - Commit hash - Author name and email - Commit message - Timestamp This is a read-only operation that does n
- Get Computer Use Status
Retrieves the status of all VNC desktop processes in a sandbox. Use this action when you need to check the current state of all VNC desktop processes running within a sandbox. The status can indicate whether services are fully operational (
- Get Daytona Config
Retrieves the Daytona platform configuration including URLs, OIDC settings, analytics, rate limits, and other platform-level settings. Use this action when you need to fetch the current Daytona configuration settings, such as the dashboard
- Get Display Info
Retrieves information about displays connected to a sandbox. Use this action when you need to get information about all displays connected to a sandbox, including their dimensions, positions, and active status. This is a read-only operation
- Get Entrypoint Logs
Retrieves entrypoint logs for a sandbox session. Use this action when you need to fetch the stdout, stderr, and combined output logs from an entrypoint process running within a sandbox. This is useful for debugging process initialization, m
- Get File Info (Deprecated)
[DEPRECATED] Gets file info inside a sandbox toolbox. Use this action when you need to retrieve detailed information about a specific file or directory within a sandbox toolbox, including its size, permissions, ownership, and modification t
- Get Git History (Deprecated)
[DEPRECATED] Get commit history from a git repository in a sandbox toolbox. Use this action when you need to retrieve the commit history of a git repository within a sandbox toolbox. This is a read-only operation that retrieves the commit l
Setup
Setup guide
- 11. In Switchy, open your workspace settings and navigate to the Integrations tab. 2. Click 'Add MCP Integration' and select Daytona from the developer tools category. 3. You'll be prompted to enter a Daytona API key — generate one in your Daytona organization dashboard under API Keys (the key displays only once, so copy it immediately). 4. Paste the key into Switchy and click 'Connect'. 5. Switchy will verify the key and list the 50 available tools. 6. Open any Project and type '@Daytona create a sandbox and clone github.com/myorg/myrepo' to test the connection — Daytona should respond with sandbox details and a clone confirmation. 7. If the command fails, double-check the API key has sandbox creation permissions in your Daytona org settings.
What teammates see: by default, memories from Daytona are scoped to the Project (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Projects have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
Clone Repo to Sandbox
@Daytona create a new sandbox, then clone the repository at https://github.com/myorg/backend into the /workspace directory. Use the main branch.
Check Sandbox Permissions
@Daytona check if I have access to sandbox ID sb-abc123. If I do, list the contents of the /workspace folder.
Prepare Test Directory
@Daytona in sandbox sb-abc123, create a folder at /workspace/test-results and another at /workspace/logs.
Archive Old Sandbox
@Daytona archive sandbox sb-xyz789. Add a note that this was the environment used for the Q4 load test.
Generate API Key
@Daytona create a new API key for our CI pipeline. Label it 'GitHub Actions Runner' and return the key value.
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@daytona list all active sandboxes in my organization and show me which ones haven't been accessed in over 7 days
Found 12 active sandboxes in your organization. 4 sandboxes haven't been accessed in over 7 days: • legacy-api-sandbox (last accessed 9 days ago, owner: sarah@team.com) • experiment-ml-model (last accessed 14 days ago, owner: mike@team.com) • hotfix-branch-test (last accessed 11 days ago, owner: alex@team.com) • prototype-ui-v2 (last accessed 8 days ago, owner: jordan@team.com) The remaining 8 sandboxes were accessed within the past week. Would you like me to archive any of these inactive sandboxes?
This example shows Daytona's sandbox inventory capabilities. The MCP can query sandbox metadata and filter by access patterns. Requires read access to organization sandboxes. Note that actual sandbox counts and access timestamps will vary by your team's usage — this is an illustrative response showing the data structure you'd receive.
@daytona create a new sandbox, clone the github.com/ourteam/backend-api repository into it, and checkout the feature/auth-refactor branch
Sandbox created successfully (ID: sb-8x9k2m). Cloning repository into /workspace... Repository cloned: github.com/ourteam/backend-api Checked out branch: feature/auth-refactor (commit a3f7b92) Sandbox is ready at: https://daytona.dev/sb-8x9k2m You can access it via SSH or the web IDE. The repository is available at /workspace/backend-api with all dependencies from the branch intact.
This demonstrates Daytona's core workflow: spinning up isolated dev environments on-demand. The MCP chains multiple tools (create sandbox, clone repo, checkout branch) into one action. Requires API key with sandbox creation permissions. Be aware that sandbox creation consumes compute resources and may hit organization quotas if you create many in quick succession.
@daytona check which sandboxes are running the backend-api repository, then summarize what branches each one has checked out and recommend which ones we could safely archive
Found 5 sandboxes running backend-api: • sb-4k7n1p: main branch (last commit 2 hours ago) — actively used by sarah@team.com • sb-9m2x5t: feature/auth-refactor (last commit 3 days ago) — stale, owner hasn't accessed in 6 days • sb-1p8q3r: hotfix/security-patch (last commit 1 day ago) — merged to main yesterday, likely safe to archive • sb-6t4w9z: experiment/graphql-migration (last commit 12 days ago) — no recent activity, owner left team • sb-2n7k5m: feature/payment-integration (last commit 4 hours ago) — active development Recommendation: Archive sb-9m2x5t, sb-1p8q3r, and sb-6t4w9z. The first two are stale post-merge, and the third is orphaned. This would free up 3 compute slots.
This example pairs Daytona's data retrieval with AI reasoning to produce actionable insights. The MCP fetches sandbox states and git metadata, then the AI synthesizes a cleanup plan. Useful for teams managing many ephemeral environments. The recommendation logic is AI-generated based on heuristics (access patterns, merge status) — always verify before bulk archiving, especially if sandboxes contain uncommitted work.
Use-case deep-dives
When Daytona beats local setup for new hires
An 8-person startup hiring two junior engineers faces the classic onboarding tax: three days of Slack threads debugging Postgres versions and missing env vars. Daytona wins here because you clone the repo into a sandbox, mount the Docker registry, and ship a working environment in under an hour. The new hire codes on day one instead of day four. The trade-off: if your stack is pure frontend with zero backend dependencies, local setup is faster and Daytona's 50 tools are overkill. But if you run microservices, databases, or any containerized infra, the sandbox model pays back immediately. Worth it once you're past founder-only mode and hiring your first three engineers.
Spinning up isolated sandboxes for sales demos
A 12-person B2B SaaS team runs live product demos for enterprise prospects, and each demo needs a clean sandbox with customer-specific seed data. Daytona's sandbox archiving and cloning tools let the sales engineer spin up a fresh environment in minutes, load the prospect's schema, and tear it down after the call without polluting staging. The API key auth means the SE doesn't need admin access to your cloud account. The limit: if your demo data is over 5GB or requires complex multi-region setup, Daytona's toolbox model gets slow and you're better off with a dedicated staging cluster. But for standard SaaS demos under 2GB, this is faster than Heroku review apps and cheaper than keeping 10 staging environments warm.
When sandboxes beat production debugging for support
A 6-person support team at a dev tools company gets bug reports with vague reproduction steps. The support engineer needs to clone the customer's repo, check out the exact commit, and reproduce the issue without touching production. Daytona's git checkout and folder creation tools let them spin up a throwaway sandbox, reproduce the bug in 10 minutes, and share the sandbox URL with engineering. The boundary: if your support volume is under 5 tickets a week, the API key setup overhead isn't worth it—just use local Docker. But once you're triaging 15+ tickets weekly and engineers are context-switching to help support, the sandbox model keeps everyone in their lane. Best fit for technical support at product-led growth companies.
Frequently asked
What does the Daytona MCP let me do in Switchy?
It gives your AI agents full control over Daytona's cloud development environments. Agents can spin up sandboxes, clone repos, switch branches, manage API keys, and check access permissions — all without leaving the chat. Think of it as letting your AI operate Daytona's dashboard and CLI on your behalf, so you can provision dev environments conversationally.
Do I need admin access to connect Daytona to Switchy?
You need an API key from your Daytona organization, which typically requires admin or owner permissions to generate. The MCP uses API_KEY auth, so whoever connects it must have rights to create keys in Daytona's settings. Once connected, the AI inherits that key's scope — if the key can create sandboxes, the AI can too.
Can the Daytona MCP run code inside a sandbox?
No. It manages sandbox lifecycle (create, archive, check access) and file operations (clone repos, create folders), but it doesn't execute arbitrary commands or scripts inside the environment. If you need to run tests or build steps, you'll still SSH into the sandbox or use Daytona's terminal directly.
How is this different from just using Daytona's CLI or web UI?
The MCP lets your AI orchestrate multi-step workflows — clone three repos, create folder structures, register a Docker registry — in one conversational thread. The CLI requires you to remember flags and syntax; the web UI requires clicking. Here, you describe intent and the agent translates it into the right sequence of Daytona API calls.
Who on my team should connect the Daytona integration?
Whoever manages your team's Daytona organization and can generate API keys. Typically a DevOps lead or engineering manager. Once connected, any Switchy user in your workspace can ask the AI to provision sandboxes, but the underlying Daytona usage and billing still tie back to your org's plan.