An open source alternative to Daytona, for running agents
Daytona is sandbox infrastructure: an API and SDKs that give your own agent a fast, isolated computer in their cloud or on your runners. Agenhood is a whole agent platform you host yourself, with the sandbox, the agent loop, schedules and a console in one MIT-licensed stack.
Last updated
Most people looking for an open source alternative to Daytona have read the notice at the top of its GitHub repository: as of June 2026, Daytona's core development has moved to a private codebase, and the repo was archived on October 3, 2026. The last public code stays usable under its AGPL-3.0 license, with no further updates. Before you pick a replacement, be clear about what you need. Daytona is a sandbox API that your own agent calls. Agenhood is a full agent platform with the sandbox built in. If a sandbox API is all you need, Agenhood is probably not your answer, and we say what to look at below.
The short answer
Pick Daytona if
- You are building your own agent and want an API that hands it a fresh sandbox in code.
- You need Linux VM, Windows, macOS or GPU sandboxes, or VM features like pause, resume and fork.
- You'd rather not run servers, or want your own runners with Daytona managing the control plane.
- You need SDKs in Python, TypeScript, Ruby, Go or Java.
Pick Agenhood if
- You want the agent loop, schedules, triggers and a console included, not only the sandbox.
- You want the whole stack, control plane included, open source and on your own server.
- One Docker host and a hardened container per agent are enough for your workload.
If you only need a sandbox API
Agenhood has no endpoint that runs a command or a code snippet on demand. You give an agent a task with a prompt, and the agent decides what to run. If your product already has its own agent loop and needs isolated machines to run code in, look at a dedicated sandbox runtime instead.
One open option is E2B Runtime, the Apache-2.0 backend behind E2B. It runs each sandbox in a Firecracker microVM, and its Embed package puts the whole stack on a single Linux host with KVM. You can also fork the archived Daytona code under AGPL-3.0, but you would be maintaining it yourself from here on.
Side by side
| Topic | Daytona | Agenhood |
|---|---|---|
| What it is | Sandbox infrastructure: an API, SDKs and CLI to create sandboxes and run code in them. You bring the agent. source | An agent platform: each agent is a sandboxed container with a driver, a model, tools and a workspace. |
| Where it runs | Daytona's cloud in shared US and EU regions, or your own runner nodes in custom regions that Daytona's control plane manages. sourcesource | One Linux VM you run, with Docker Compose. No Kubernetes. |
| Source code | Core development moved to a private codebase in June 2026. The last public release, v0.190.0, stays available under AGPL-3.0 in an archived repo. sourcesource | MIT, the whole stack: API, console, agent image and drivers. |
| Isolation | Container sandboxes with their own namespaces and hard resource limits. Linux VM and Windows sandboxes with their own kernel. GPU sandboxes. source | One hardened container per agent: read-only root filesystem, dropped capabilities, CPU and memory caps. Shares the host kernel. |
| Outbound network | A firewall per sandbox. On Tier 3 and 4, block all traffic or allow listed domains or CIDR ranges. Restricted on Tier 1 and 2. source | Internal network with no gateway. One filtering egress proxy blocks private ranges and cloud metadata. One deny list for the whole server. |
| State between runs | Persistent by default: files survive stop and start, stopped container sandboxes can be archived to object storage, and volumes outlive sandboxes. source | A /workspace volume per agent across restarts and pauses. Idle agents pause and wake on the next task. |
| Idle handling | Sandboxes stop after 15 minutes of inactivity by default. A sandbox is only deleted when you delete it or ask for that. sourcesource | Pause after 20 idle minutes and archive after 3 days, by default. An archived workspace is deleted after 30 days unless the server admin changes the limit. |
| Undo | Snapshots of a sandbox filesystem (and memory on VM sandboxes), used as templates for new sandboxes. source | Without a linked Git repo, a Git snapshot of the workspace after every task, with rollback that adds a new snapshot instead of deleting history. |
| Agent loop | None built in. Guides show how to run Claude Code, Codex, OpenCode and other agents inside a sandbox. source | Five drivers chosen per agent: Vanilla, Opencode, Codex, Claude Code and a single-call API driver. Anthropic and OpenAI models, plus Opencode's own model plans. |
| Events and triggers | Webhooks for sandbox, snapshot and volume events. Scheduling and chat triggers are left to your code. source | Schedules, multi-step workflows, GitHub and Slack triggers, and a live SSE stream of every task. |
| Interfaces | SDKs for Python, TypeScript, Ruby, Go and Java, a REST API, CLI, MCP server, dashboard, SSH and a web terminal. source | REST API plus server-sent events, a web console and an in-browser terminal into each agent. |
| Pricing model | Usage-based, billed per second for reserved vCPU, memory and disk, with free credit to start. See their pricing page. sourcesource | Free. You pay for your server and for model usage on your own keys. |
A sandbox you call, or an agent you give work to
With Daytona, your code is in charge. It creates a sandbox through the API or an SDK, uploads files, runs processes and reads the results, and a daemon inside each sandbox carries out those calls. Daytona's guides show how to install Claude Code, Codex or OpenCode in a sandbox, but starting the agent, passing it credentials, keeping its output and deciding when to shut it down is your job.
With Agenhood, the agent is the unit. You create it once with a driver and a model, then send it tasks. The agent loop runs inside its container, and the console and API show every message, tool call and file change as it happens.
# An agent with its own container, workspace and resource caps
curl -X POST http://localhost:5173/v1/containers \
-H "Authorization: Bearer tk_live_seedkey" \
-H "Content-Type: application/json" \
-d '{"name": "release-notes", "config": {"driver": "claude-code", "model": "sonnet"}, "resource_limits": {"mem_limit": "2g", "cpus": 1}}'
# Submit a task to an agent (agents are "containers" in the API)
curl -X POST http://localhost:5173/v1/containers/$AGENT_ID/tasks \
-H "Authorization: Bearer tk_live_seedkey" \
-H "Content-Type: application/json" \
-d '{"prompt": "Summarize the latest release notes and save them to notes.md"}'
# Stream the live event feed (assistant messages, tool calls, file changes)
curl -N http://localhost:5173/v1/containers/$AGENT_ID/tasks/$TASK_ID/events \
-H "Authorization: Bearer tk_live_seedkey"
Use the id from the create response as $AGENT_ID and the
task_id from the submit response as $TASK_ID. Agents start in under 5
seconds once the agent image is on the host.
Isolation: a VM option, or a hardened container
Daytona offers several kinds of boundary. Its isolation docs describe container sandboxes with their own namespaces and hard vCPU, memory and disk limits, and VM sandboxes with their own kernel that can also pause, resume and fork. Each sandbox can be locked down further with a domain or CIDR allow list, or cut off from the internet entirely.
Agenhood has one kind: a Docker container per agent with a read-only root filesystem, dropped Linux capabilities and CPU and memory caps. Agents sit on an internal network with no gateway, and the only way out is a filtering egress proxy that blocks private IP ranges and cloud metadata endpoints. That is a solid default, but it is a container on a shared kernel, and the deny list applies to the whole server, not to one agent.
Running it yourself
Daytona's self-managed option is Bring Your Own Compute: you attach your own runner nodes to a custom region, deploy region services with Helm charts on Kubernetes, and Daytona's hosted control plane schedules sandboxes onto them. Their pricing page lists BYOC under Enterprise.
Agenhood runs entirely on your machine. make dev starts it locally with nothing to
configure, and make prod runs it on a VM behind Traefik with Let's Encrypt. The control
plane, database, console and agents all live on that one host, and so do your keys, which are
stored encrypted.
What Daytona does better
- Stronger boundaries when you need them. Linux VM and Windows sandboxes with their own kernel, GPU sandboxes, and macOS sandboxes through use.computer. Agenhood only has containers on a shared kernel.
- Built for scale. Fast creation, regions and custom regions with your own runners. Agenhood runs on one Docker host.
- A real sandbox API. SDKs in five languages, process and file operations, and VM snapshots, pause, resume and fork. Agenhood only takes tasks.
- Finer network rules. Allow lists per sandbox, by domain or CIDR. Agenhood has one deny list for every agent.
- Nothing to operate. On Daytona's cloud there is no server to patch or back up.
Moving over, or using both
If you used Daytona to run coding agents, Agenhood can take that whole job. Run make dev,
add an Anthropic or OpenAI API key under Settings, Credentials, and create one agent per job with the
Claude Code, Codex or Opencode driver. What you did with setup scripts in a sandbox becomes the agent's
workspace, which stays between tasks. Put recurring jobs on a schedule, or start them from a GitHub
comment or a Slack message.
If your product calls Daytona for many short-lived code runs, keep a sandbox API for that and use Agenhood for the long-lived agents around it, such as a nightly research job or a reviewer that answers in GitHub.
What it doesn't do
- Not a sandbox API. You can't create a bare sandbox and run code in it from your own program. For that, use a sandbox runtime such as E2B Runtime.
- It is a hardened container, not a VM. Agents share the host's kernel. For a stronger boundary, give Agenhood its own VM.
- One Docker host, and you run it. No GPU or Windows sandboxes, no Kubernetes and no hosted version, so updates and backups are on you.
Questions people ask
Is Daytona still open source?
Daytona's README says that as of June 2026 its core development moved to a private codebase. The old repository was archived on October 3, 2026, and stays public under the AGPL-3.0 license it had at v0.190.0, with no further updates. Daytona's SDKs, API clients and CLI are published in a separate public repo.
Can Agenhood replace Daytona as a raw sandbox API?
Not well. Agenhood has no endpoint for running a command or a piece of code directly; work goes to an agent as a task with a prompt, and you get files, events and results back. If your product needs sandboxes on demand for your own agent loop, use a sandbox API such as E2B's open-source runtime, or Daytona itself.
Is an Agenhood agent as isolated as a Daytona sandbox?
It depends on which Daytona sandbox you compare. Daytona's container sandboxes and Agenhood agents are both containers that share the host kernel. Daytona's VM sandboxes have their own kernel, which is a stronger boundary than Agenhood offers. Agenhood adds a hardened container, an internal network with no gateway and a filtering egress proxy.
Can I run Claude Code or Codex in both?
Yes. Daytona's guides show how to install and run them inside a sandbox from your own code. In Agenhood they are built-in drivers you pick per agent, next to Vanilla, Opencode and a single-call API driver. Agenhood supports Anthropic and OpenAI models, plus Opencode's own model plans through the Opencode driver.
What does each one cost?
Daytona bills per second for the vCPU, memory and disk a sandbox reserves, with free credit to start; see their pricing page for current rates. Agenhood is free and MIT licensed. You pay for the server you run it on and for model usage on your own keys.