Eclipse Enclave 1.0 Release: Sandbox for Coding Agents
The Eclipse Foundation launched Eclipse Enclave 1.0 on November 19, 2026, an open source, vendor-neutral runtime and sandbox that lets AI coding agents run autonomously in isolated, policy-controlled environments. Enclave currently supports Claude Code, Codex and OpenCode, with an extensible architecture for additional tools. It is available now under the MIT license at enclave.eclipse.dev, and the repository at github.com/eclipse-enclave/enclave, written in Go, had 85 stars at the time it was observed.
The problem Enclave targets is permission, not capability. Coding agents now write and modify software, execute commands, install dependencies and run tests on their own. Giving that autonomy on a developer machine means exposing SSH keys, other repositories and customer source code, while approving every command by hand destroys the speed the agent was supposed to provide. Enclave answers by running each agent session in its own isolated container with defined access to files, networks and development resources, so agents can work independently and in parallel without unrestricted access to the host.
What the 1.0 Release Includes
The launch announcement names Claude Code, Codex and OpenCode as supported agents. The project blog from EclipseSource lists a wider built-in set, adding Codex CLI, Theia AI, Pi and Mistral Vibe, each running in its fully autonomous mode inside its own sandbox, with further harnesses and container features addable as extensions. Docker is the default containerization backend, and the repository also carries an experimental QEMU microVM backend.
Four capabilities anchor the release. Sessions run in controlled environments that limit access to sensitive files and resources. Multiple agents can run simultaneously on separate tasks, keeping their work isolated and easier to review. Access to external services and sensitive information is restricted, with mechanisms for protecting API keys and OAuth tokens. Sessions persist, so work can resume without losing progress or configuration, and developers can switch between supported agents rather than committing to one vendor sandbox.
A new report from 451 Research, part of S&P Global, titled Eclipse Foundation raises the governance and security stakes for AI agents, identifies that consistent isolation and policy control across supported agents as a source of immediate enterprise value. The announcement cites the report as context, and no large scale adoption figures have been published yet, so the enterprise claim should be read as an analyst assessment rather than measured deployment evidence.
How a Session Works in Practice
Running enclave in a project directory starts an isolated session. Enclave builds the container with the agent pre-installed, sets up the mounts, caches the agent authentication tokens so login happens once instead of on every run, configures the network, and drops the developer into a session with permission prompts already switched off. The agent sees the starting directory mounted at the same absolute path as on the host, so paths and builds behave the same inside and outside. One level up does not exist as far as the agent is concerned, and host home configuration and environment are trimmed so secrets do not leak into the container by default.
Additional access is explicit. A related repository can be mounted read only with --add-readonly-dir <path>, specific environment variables pass through with --pass-env <KEYS>, and reviewed agent configuration can be shared through host config passthrough. Enclave also wraps an existing devcontainer instead of replacing it: enclave devcontainer generate takes an existing setup and adds the isolation around it, so the tooling a project already declares remains the tooling the agent uses to build and test.
Parallel work follows the git worktree pattern the project team describes as its normal day: one branch, one directory, one agent, with three or more sessions at once. Sessions can also run detached with enclave --background --name refactor-parser, be listed with enclave ps, and be re-entered with enclave attach. That workflow matters because it turns sandboxing from a security tax into the default way sessions are organized.
Network Allowlist and Secret Handling
All outbound traffic leaves through a gateway sidecar that filters DNS and proxies requests against a domain allowlist. Each agent harness configures its own requirements: Claude Code can reach the Anthropic API because that domain is on the list, while everything else is blocked and logged. Adding a domain is a single command, enclave network add-domain eclipsesource.com --global, which keeps the policy visible and editable rather than buried in container configuration.
Secrets follow the same separation. A secret declared to Enclave appears inside the container only as a placeholder, and the gateway swaps in the real credential on the way out. The agent can call an API it is allowed to call without ever reading or leaking the token. Combined with cached authentication, that design addresses the two failure modes that make teams nervous about autonomous sessions: an agent exfiltrating credentials it was handed, and a poisoned instruction in an issue comment steering an agent somewhere it should never reach.
The project is unusually precise about the boundary of that protection. The allowlist decides which hosts an agent can reach, not what those hosts send back, and Enclave narrows an agent access to your machine rather than acting as a runtime escape boundary. That honesty is useful for adoption decisions: Enclave is a control layer for access and traffic, and teams still own the risk of the content that allowed services return.
Origin at EclipseSource and the Foundation Move
Enclave began inside EclipseSource in late 2025 as an internal sandbox called YOLOArena. The engineering team built it so its own developers could run agents at full autonomy without risking their laptops or leaking secrets, and many of them used it daily while it hardened. EclipseSource then contributed the technology to the Eclipse Foundation so a broader developer community could develop it collaboratively.
The Foundation framing is part of the product argument. A sandbox decides which domains agents may reach, which files they may touch and what gets recorded, and the project team argues that layer should be code a team can read, audit and change, governed by a vendor-neutral foundation rather than shipped as a single vendor binary. Enclave also sits next to the Foundation wider AI ecosystem, including Eclipse Theia, Eclipse LMOS, Eclipse PanEval and a vendor-neutral AI Registry, currently in preview, for discovering MCP servers, agent skills and plugins with provenance and approval signals.
Limits and Unconfirmed Points
- Platform requirements: Enclave runs natively on Linux and macOS, and on Windows through WSL2. It needs a rootful Docker daemon with buildx, and rootless Docker is not supported yet.
- No detailed 1.0 changelog: the announcement does not separately itemize what changed from earlier preview versions, so the delta from preview to 1.0 is unconfirmed.
- Graphical interface is not stable: HomeShell, a companion interface that groups projects and workstreams and shows session state, is in development and has no stable release yet.
- Allowlist scope is narrow by design: the allowlist controls reachable hosts, not the content those hosts return, and Enclave is not presented as a container escape boundary.
- No published adoption scale: the 451 Research report is cited for enterprise value, but no large scale deployment cases or figures have been published.
Read with those limits, the release still marks a clear direction. The bottleneck for putting coding agents to work is shifting from model quality to the control layer around them, and Enclave packages that layer, per session containers, a network allowlist and placeholder secrets, as vendor-neutral open source that Claude Code, Codex and OpenCode can share. Teams evaluating it should weigh the rootful Docker requirement and the unfinished graphical interface against a benefit that compounds with every parallel session: autonomy that no longer requires handing over the whole machine.
FAQ
What is Eclipse Enclave 1.0?
Eclipse Enclave 1.0 is an open source, vendor-neutral runtime and sandbox released by the Eclipse Foundation on November 19, 2026. It runs AI coding agents autonomously in isolated, policy-controlled environments, and it is available now under the MIT license at enclave.eclipse.dev.
Which coding agents does Enclave support?
The launch announcement names Claude Code, Codex and OpenCode. The project blog lists a wider built-in set: Codex CLI, Theia AI, Pi and Mistral Vibe are also supported out of the box, and further harnesses can be added as extensions.
How does Enclave protect API keys and OAuth tokens?
Secrets appear inside the container only as placeholders. The network gateway swaps in the real credential on the way out, so an agent can call an allowed API without being able to read or leak the token itself.
What does Enclave require to run?
Enclave runs natively on Linux and macOS, and on Windows through WSL2. It needs a rootful Docker daemon with buildx, and rootless Docker is not supported yet, according to the project blog.
What does the network allowlist not guarantee?
The allowlist decides which hosts an agent can reach, not what those hosts send back. The project is precise that Enclave narrows an agent's access to your machine rather than acting as a runtime escape boundary.
Related Reading
- Claude Cage Release: Isolated VM, 3,181 Stars in 11 Days, another open source attempt to give a coding agent an isolated environment instead of the host machine
- Claude Code Cloud Auto Setup: Plans and How It Works, the hosted counterpart to running agents in a controlled environment you operate yourself