Run Your First Parallel Task

A walkthrough of the thing Daintree exists for: create two worktrees, launch an agent in each, watch their states rather than their output, and review each result on its own before it merges.

Reviewed Aug 18, 2026

Everything up to here has been set up. This is what the setup was for: two agents working on two different changes at the same time, in the same repository, each on its own branch in its own checkout. Then one place where you read both results before either merges.

It takes about fifteen minutes. Do it once deliberately, on a repository you do not mind experimenting in. Learning what the isolation covers halfway through real work is a bad time to find out.

Before you start

Daintree installed, with at least one agent CLI that launches.
A Git repository open as a project. Worktrees need one. See Open your first project if the folder you opened is not a repository yet.
A clean working tree on your base branch. Not required, but it makes the diff at the end easier to read.
Two small, independent tasks. "Add a README badge" and "rename a helper" work well. Pick tasks that touch different files, so the first thing you learn is the workflow rather than conflict resolution.

1. Create two worktrees

A worktree is a second checkout of the same repository, on its own branch, in its own directory. Two agents in two worktrees are editing two separate sets of files on disk. Neither writes over the other's working copy, and neither has to wait for the other to finish.

Press Command-K, then Command-N Control-K, then Control-N Control-K, then Control-N , or click + in the worktree sidebar. The Create New Worktree dialog opens in New Branch mode.
Type a branch name for your first task. As you type, Daintree suggests type prefixes. Accept feature/ or chore/ if one fits. The Worktree Path fills in from your path pattern. Leave it alone.
Create it. Daintree makes the branch, checks it out into its own directory, and selects it.
Do the same again for your second task, from the same base branch.

You now have two cards in the sidebar. Each is a real directory on disk with its own checkout. Run git worktree list in a terminal if you want to see them from outside Daintree.

Note

Both worktrees branch from the same base, so both start from identical code. That is what makes each result independently reviewable at the end: both diffs are measured from the same starting point.

Warning

A worktree isolates changes, not processes. Each agent runs as your user account and can reach the rest of the filesystem, the same as it would in a terminal. Separate checkouts stop two agents editing the same working copy. They are not a sandbox. See Remote Compute for actual process isolation.

2. Launch an agent in each

Select the first worktree card, then open the launcher and start an agent. Claude Code has a default shortcut of Option-Command-C Control-Alt-C Control-Alt-C . Codex is Option-Command-X Control-Alt-X Control-Alt-X . Any agent works.

The agent starts in that worktree's directory, on that worktree's branch. You do not cd anywhere and you do not check anything out. The panel is already in the right place. Give it your first task.

Now switch to the second worktree and launch a second agent there with the second task. Click its card, or press Option-Command-2 Control-Alt-2 Control-Alt-2 , which selects the second worktree in the sidebar as it is currently sorted.

Tip

Switching worktrees swaps which panels you are looking at. It does not stop anything. The first agent keeps running while you are looking at the second, and that is worth watching happen once.

3. Watch, without watching

Two agents are running and you have one screen. Rather than switching between them to check, let the states come to you:

The worktree cards carry agent state on each row, aggregated into a single status when the card is collapsed. A waiting agent is one that needs an answer from you.
Pilot (Option-Command-O Control-Alt-O Control-Alt-O ) lists every run across every project, grouped by workspace and ordered inside each group by what needs attention. With two agents it is overkill. With twenty it is the view that scales.
Notifications tell you when an agent gets blocked or finishes, so you can look away. Completion popups are off by default and OS notifications need Watch enabled, so spend a minute in Settings > Notifications deciding what should reach you.

Answer whichever agent asks first. The other keeps working while you do. Nothing is queued behind your attention.

4. Review each result separately

When an agent finishes a run that changed files, a banner appears at the bottom of its pane reading "N files changed, review when ready." Click Review to open Review Hub for that worktree.

It opens in Working tree mode: a Staged section, a Changes section, and the commit composer. Because the two tasks ran in separate worktrees, you are reading one agent's work at a time, with nothing of the other's mixed in. Stage what you want, write a commit message, commit, and push. Then switch to the other worktree and do the same.

Warning

Review is the point of the arrangement, not a formality. Two agents can produce two plausible diffs in the time it takes to read one, and Daintree does not gate git: an agent can run git itself in its own terminal. The separation buys you the ability to judge each result on its own. It does not judge them for you.

5. Clean up

A merged worktree has done its job. Delete it from the card's menu. The dialog spells out what will happen before you confirm: the directory goes, the branch goes if you ask for it, and Close all terminals is checked by default.

Uncheck Close all terminals and the agents survive the deletion. The row stays in the sidebar as a deleted-worktree card with a countdown, and you can drag a terminal from it onto a live worktree to keep the session. The directory is still gone, so this rescues the running sessions rather than the files. See Deleted Worktrees for the full behavior.

What you just learned

The habit	What replaces it
One agent at a time, so two cannot tread on each other	One worktree per task, so their working copies are separate
Checking each terminal to see if it needs you	States on the cards, and Pilot when there are too many cards
`git diff` in whichever terminal is current	Review Hub, scoped to one worktree's changes
Merging when the agent says it is done	Merging when you have read it

Two is the demonstration. The arrangement does not change at five or at twenty. You add worktrees, and the attention surfaces do the sorting. Fleet is where you send one instruction to several agents at once instead of one at a time. Recipes is where a workspace you set up by hand here becomes one click next time.