Security & Privacy
Daintree's renderer policies, IPC validation, browser and content permissions, Git and plugin boundaries, pattern-based diagnostic redaction, permission bypass, storage and data flows.
Daintree runs coding agents with real filesystem and network reach, inside your repositories, on your machine or on a remote host you have added. That is the whole point of the habitat, and it is also the reason this page exists. Everything below describes a boundary that is enforced in code, plus the handful of places where the honest answer is that no boundary exists and you are trusting something.
Windows is fully tested and supported.
The boundaries
Five areas carry enough detail to have their own page. They fail in unrelated ways, so they are documented apart rather than as one long list:
- Desktop and IPC. Renderer sandboxing, the separation between the UI and the processes with real system access, IPC validation and rate limiting.
- Browser and content. Content
Security Policy, Trusted Types, the embedded browser, permission lockdown, the
daintree-file://protocol, and what happens to an external link. - Git, process and environment. Git command and pathspec hardening, lifecycle script injection, secret scrubbing, environment filtering, and what skip-permissions actually turns off.
- Privacy and data. What is stored and where, what telemetry does and does not send, what Canopy reads and where, and macOS folder access.
- Remote hosts. SSH as the way into a host (WSL on Windows), cloud provider credentials and host keys, the private socket and per-launch token in place of a network port, what crosses the network, credentials that stay on each machine, and why control of a project is not a permission.
Plugin trust
Plugins are the one surface where third-party code runs inside Daintree, and the trust model is deliberately explicit about what it does and does not promise.
A plugin's main entry runs in a utility worker, while a contributed React view runs in the app renderer. The host API applies capability, scope, and consent checks to its own methods. That provides specific controls and worker crash recovery, but the normal plugin worker is not a Node sandbox: direct Node filesystem, process, and network calls are not contained by the manifest's host API scopes.
What a plugin inherits is narrowed separately. The plugin worker, the processes a plugin starts and the MCP servers a plugin ships all get an allowlisted environment (path, locale, temp and OS essentials, plus proxy and certificate settings for the worker and MCP servers), so the API tokens in Daintree's own environment don't reach them. That keeps inherited secrets out of a plugin's environment; it does not stop plugin code reading a file your account can read.
Project-level plugins add executable code to a repository under .daintree/plugins/. Discovery stages them for review; folder trust and project activation are separate from merely opening the repository. Review plugin source and the built entry points before trusting a folder. Trust is local to the user, not something a collaborator grants by committing a file.
Install or trust plugins as code that can run with your account's permissions. An archive hash identifies bytes; without an independently trusted expected hash or signature, it does not authenticate a publisher. Worker isolation also does not isolate a plugin's React view from the app renderer.
The full capability list, the compound-capability lattice, the scope semantics and the install pipeline are documented in Plugin trust and capabilities.
MCP server
Daintree exposes an opt-in local MCP server for external tools, and it also provisions per-session MCP wiring for the agents it launches itself. The two have separate trust boundaries.
Network and auth
The local server is disabled by default and binds to 127.0.0.1 only, so Daintree does not expose a network listener on external interfaces. On first start it generates a bearer key in the format daintree_<32-hex>, compared timing-safely on every request, and the transport additionally requires a matching loopback Host and validates an optional Origin as a matching HTTP loopback origin. Rotating the key from Settings > MCP server invalidates every external client holding the old one.
The loopback in question is that of the machine the server runs on. In a window on a remote host, agents use the host's own MCP server, bound to the host's 127.0.0.1 and configured in the host's settings. What those agents may do in your window is a short allowlist of project actions; see Agents on a Host and Your Window.
Four properties are worth repeating here because they are access-control boundaries rather than conveniences: destructive calls confirm in Daintree, never through client-declared elicitation; project settings are not readable over MCP (project.getSettings is on no tool set and not on the external surface, so run commands and secure environment variables never cross the server); introspection is scoped to the calling session's own tier; and the external fullToolSurface opt-in was removed outright: it used to expose 335 of 426 actions to any API-key caller, and nothing replaces it. The full model is in MCP authorization.
Agent panes, the agents Daintree launches with its MCP server wired in, are the one kind of session where a project's tier is an approval line rather than a ceiling. A call to a tool above the tier opens Daintree's own confirmation dialog instead of failing. Ticking Allow for the rest of this session there lets that agent's later calls to the same tool run without asking, with any arguments, for up to 30 minutes. An agent pane can type only into terminals its own session created, unless you hand it one from that terminal's context menu, which you can take back the same way. See Agent panes.
Cross-agent token isolation
Every agent pane that gets MCP wiring receives its own bearer, minted for that pane and revoked when its terminal exits or the spawn fails. A bearer that belonged to an earlier launch is not carried into a new one.
Daintree Assistant sessions add a second check. A help session's token is bound to the agent it was provisioned for, Claude Code, Codex or Copilot, and handing it to a launch of a different agent refuses to spawn rather than falling back. This is a hard spawn failure (the process never starts), not a silent downgrade.
The literal bearer is kept out of command-line arguments. Each agent gets the wiring in the form its CLI reads: Codex reads the bearer from the PTY environment; Claude Code and several other CLIs read a configuration file Daintree writes owner-only (0600) before the launch; a few take the configuration through an environment variable. This reduces argument-list exposure; it does not make environment variables, temporary files or arbitrary logs secret-proof.
App-level guards
Two smaller behaviors that exist to prevent accidental loss rather than to stop an attacker:
- Single instance. Only one copy of Daintree runs at a time. Launching it again hands that launch's arguments (a folder, a plugin archive, a
daintree://link) to the running copy and exits at once: a plain relaunch focuses the existing window, and a folder opens in an empty or new window. This avoids conflicts over file locks and terminal processes. - Window close protection. Command-W Control-W, or Control-F4 Control-W closes the focused panel, not the application window, so a reflexive keystroke does not take a set of running agent sessions with it.