Skip to main content

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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

Where this differs from a vendor’s own agent app
Vendor appDaintree
Which agents runThat vendor’s own agent17 built-in agent CLIs, each on your own subscription
Which machines run themThis machine, a box over SSH, or the vendor’s cloudThis machine and your Mac and Linux hosts, each one’s load in view
Who starts the runsYou, or that agent’s own subagentsYou, or an Assistant that starts and steers runs on any host
How you keep trackA session list for that one agentCanopy 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.

Remote Hosts

Put the agents where the compute is.

From Daintree on a Mac or Linux laptop, point a window at a Mac Studio, a Linux server or a rented VM, and Daintree runs there. Projects, worktrees, terminals and agents live on the host, and the window on your laptop shows them and takes your keyboard. Close the laptop and they keep running.

Each machine you add becomes part of the habitat your agents live in. The Hosts overview shows every host's CPU and memory and suggests the least loaded for new work. It is your own ssh, to machines you chose, with no Daintree relay in between.

  • Macs and x64 Linux, including headless servers
  • Each machine keeps its own settings and sign-ins
  • A host that stays awake keeps working while your laptop sleeps
Atlas Ledger
Agents on studio-01 CPU 61% · memory normal · 2 ms
  • feature/settlement-export @studio-01 working
  • feature/fx-backfill @studio-01 waiting
  • refactor/matcher @studio-01 working
  • test/reconcile-fixtures @studio-01 working
  • chore/deps @studio-01 working
This window runs on studio-01. Open the host menu beside the project name to switch machines.

Daintree Assistant

One Assistant above every project and host.

The global Assistant sits above each project's Assistant and the agents they launch. It plans the work, opens worktrees on any host, launches agents into them, and wakes when one starts waiting. Schedules hand it work on a plain-words timetable. Every call goes through Daintree's own permissioned tools and into a local audit log.

  • Your CLI, your subscription: Daintree launches Claude Code, Codex or Antigravity in its sidebar, signed in the way you already use it, using the CLI's default model or the choice you saved for that agent.
  • Runbooks first: before it acts, it looks up Daintree's written procedure for the task, so fanning work out or chasing a stuck agent follows a known procedure rather than an improvised one.

Model traffic goes from the CLI to your provider. Daintree neither relays it nor bills for it. The runbook lookup sends Daintree a one-sentence summary of the task, written to leave out names and numbers.

api-server

you ship the auth fix across all five worktrees

▸ Spawned 5 agents: 3 on studio-01, 2 here

▸ Watching terminals

⚠ studio-01 feat/billing: “Overwrite migration 0009?”

the other four are still working

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.

See all 17 built-in agents 

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 documentation 
All agents
daintree-website2
mobile-client1
api-gateway
design-system
data-pipeline
dashboard
Select a tab or agent to try it yourself.

Verify

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.

Review & Commit fix/auth-retry
CI pending on PR #4824 passed, 1 running
0/4 viewed

src/lib/auth/session.ts

Diff excerpt+62−14
 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()); }
Sample changes, with the first file open. Go back to review the other three.

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.

Explore feature guides 

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

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