Run more agents than one machine can hold.
Daintree is an open-source meta-harness for Claude Code, Codex and 15 more agent CLIs. Spread them across your laptop and your Mac and Linux hosts over SSH. A hierarchy of assistants keeps track and brings you only what needs a decision.
- Agents
- Including Claude Code, Codex, Antigravity, OpenCode, Cursor, GitHub Copilot. 17 built-in agents, each task in its own Git worktree.
- Hosts
- Macs and Linux over your own SSH, lid closed.
- Hierarchy
- One Assistant above every project and host.
- Terms
- Apache 2.0. No account, no model relay. Source(opens GitHub in a new tab)
An animated reconstruction of the Daintree interface, running on sample project data. The walkthrough below is a recording of the real app.
Review isn’t the bottleneck anymore. Your machine is.
Current models write code you can check by running it. What runs out first is CPU, memory, test capacity, and your ability to keep track of twenty agents. Daintree spreads the work across your hosts and keeps track of it for you.
1,769 pull requests merged in the 30 days ending .
One loop, whichever agent and whichever host
Delegate
Hand a task or a batch of GitHub issues to the Assistant, or launch any agent CLI yourself. Each task gets its own branch and worktree.
Distribute
Put the work on the machine with room for it. The Hosts overview shows every host’s CPU and memory, and suggests the least loaded.
Answer
Canopy reads every agent’s screen and ranks the runs by what they need from you. Answer a prompt from the list, or from your phone.
Verify
Open the running app in a Dev Preview, forwarded from whichever host built it. Read the diff in Review Hub when the change calls for it.
Run the loop yourself, in about fifteen minutes
Walkthrough
How I run the loop on a real project
I’m Greg Priday, and I build Daintree. This is how I run several agents on a real project: organizing worktrees, using Pilot to find the runs that need me, and reviewing changes before I merge them.
| Vendor app | Daintree | |
|---|---|---|
| Which agents run | That vendor’s own agent | 17 built-in agent CLIs, each on your own subscription |
| Which machines run them | This machine, a box over SSH, or the vendor’s cloud | This machine and your Mac and Linux hosts, each one’s load in view |
| Who starts the runs | You, or that agent’s own subagents | You, or an Assistant that starts and steers runs on any host |
| How you keep track | A session list for that one agent | Canopy ranks every agent on every host by what it needs |
Where this differs from a vendor’s own agent app
- Which agents run
- Vendor app That vendor’s own agent
- Daintree 17 built-in agent CLIs, each on your own subscription
- Which machines run them
- Vendor app This machine, a box over SSH, or the vendor’s cloud
- Daintree This machine and your Mac and Linux hosts, each one’s load in view
- Who starts the runs
- Vendor app You, or that agent’s own subagents
- Daintree You, or an Assistant that starts and steers runs on any host
- How you keep track
- Vendor app A session list for that one agent
- Daintree Canopy ranks every agent on every host by what it needs
It is not an IDE either. Daintree sits above the agent CLIs you already run, not inside another VS Code fork. It is a habitat for delegating work and reviewing it, rather than an editor for typing it.
Works with the CLI you already run
- Claude Code
- Codex CLI
- Antigravity
- OpenCode
- Cursor Agent
- GitHub Copilot
Plus eleven more built in, with live state detection for each. Run the real binaries with your existing config and subscription, or add another agent through a plugin.
Attention
Twenty agents running. Three of them need you.
Canopy reads each agent’s screen with a small model that ships inside Daintree, and ranks every run on every host by what it needs. A permission prompt comes first, then a question, then a finished run.
Answer from the list without opening the terminal. Away from your desk, turn on Decisions and an agent’s question reaches your phone, end-to-end encrypted through a relay in your own Cloudflare account.
Pilot shows the same runs inside each window, grouped by project, with the waiting ones on top.
Pilot documentationVerify
Check that it works.
Then read what matters.
A Dev Preview runs the worktree’s dev server and shows the app inside Daintree, with the port forwarded from whichever host built it. Click an element and send it, with its source, to the agent in that worktree.
For the changes where reading still counts, Review Hub puts the diff beside merge readiness and live forge checks. Commit and push from the same view.
src/lib/auth/session.ts
export async function requestWithAuth(url) {- return fetch(url, withToken());+ const response = await fetch(url, withToken());+ if (response.status !== 401) return response;+ await refreshSession();+ return fetch(url, withToken()); } Workspace capabilities
The workspace around every agent
Every Agent, One Window
Runs the agent CLIs already on your machine, in parallel, with your existing config
Parallel Worktrees
Every task on its own branch and checkout
Unified Input
One set of @files, /commands, and shortcuts, working with every agent
Chat Portal
Ask any agent a question without switching context
GitHub Integration
Pick issues in bulk; each one gets its own worktree and agent
Also inside: Schedules, voice input, plugins and project apps, an MCP server, terminal recipes, themes, and remote compute.
Blast radius and trust
Every boundary is explicit
Know what separates your agents, where their processes run, and where your code goes.
Changes
Every task gets its own branch and checkout
Separate branches and checkouts keep parallel agents from overwriting each other’s work or changing your current tree.
The boundaryIt is Git isolation, not a sandbox. The agent process still runs as your user.
Process
Run the work somewhere that is not your laptop
Give each worktree a Docker stack, cloud VM, or remote sandbox. Daintree runs your provision, pause, and teardown commands as the worktree changes.
The boundaryProcess isolation comes from that environment. Configure it before turning permission checks off.
Daintree itself
No relay, no control plane, no account
Source, diffs, and terminal output pass through no Daintree backend. Remote hosts connect over your own ssh, straight to machines you chose. Decisions, when you turn it on, relays through your own Cloudflare account. Telemetry and MCP are off by default. Enable MCP and it binds to localhost with four authorization tiers.
The boundaryAgent CLIs still contact their providers. Plugins execute code; their manifests declare intent, not confinement. The Assistant’s docs and runbook search are Daintree-hosted, and the runbook lookup sends a one-sentence task summary. Canopy reads agent screens locally; while it is on, it checks Hugging Face once a launch for a newer model.
- Latest release
- v0.51.0
- License
- Apache 2.0
- Built-in agents
- 17
- Source
- daintreehq/daintree
Your agents, on machines you own
Run the real CLIs, spread them across your hosts, and answer only what needs you.
- No account for the app