Run a canopy
of coding agents.
One PRD per workspace. All looping autonomously, all at once. Each workspace is an isolated git worktree — agents build in parallel, committing as they go. Start a canopy, walk away, and steer from anywhere.
More than parallel.
Truly autonomous.
Truly parallel.
Workspaces are isolated git worktrees — agents never touch each other's files, create conflicts, or share state. Spin up two. Spin up ten. Each one builds independently on its own branch, simultaneously.
PRDs, not prompts.
Drop a plain-markdown spec into a workspace. Canopy decomposes it into tasks and keeps the agent iterating through them autonomously — one commit per task, until the work is done. Describe the work once; Canopy takes it from there.
Local-first. Open source.
No Canopy account. No telemetry. Your code and credentials stay on your machine. The core is MIT licensed — free to use, inspect, and contribute to. Bring your own agent; Canopy orchestrates it on your credentials.
Parallel agents are
table stakes now.
Every tool in this space runs agents in isolated worktrees. The question is what happens when the agent’s turn ends — who checks the work, and where the state lives.
only
TUI / CLI: Claude Squad, uzi, chief · GUI tools: Conductor, Crystal, Polyscope, Sculptor · Cloud agents (Devin, Jules, Codex cloud, Factory) are server-side — different axis entirely, not shown.
From spec
to merged diff.
Write a PRD. Start the loop. Go wide. One commit per task, all workspaces at once.
Write a PRD
Describe what you want built in plain markdown. One feature, one workspace. Canopy breaks it into tasks automatically.
Run the loop
Canopy runs your agent through the tasks autonomously — iterating until each one is done, one commit per task. No babysitting required.
Go wide
Open more workspaces, each with its own PRD. They all loop in parallel, fully isolated. That's a canopy.
n workspaces · n agents
Review & merge
Inspect live diffs per workspace. Per-task commits, clean history — no giant untangleable changesets. Merge when you're happy.
Everything the loop needs.
Nothing it doesn’t.
Prerequisites: macOS and Claude Code installed and authenticated.
Parallel workspaces
Multiple agents working simultaneously in isolated git worktrees. Shared object store, zero interference. Spin up as many as your machine can handle.
Autonomous loop
Drop in a PRD, start the loop. Canopy runs the agent through tasks iteratively — one commit per task, unattended, until the work is done.
Bring your own agent
Canopy orchestrates the agents you already use — Claude Code today, more planned. Your credentials, your account. Canopy never proxies or resells your usage.
Live diff + commit history
Unified diff with per-task commit breakdown. Clean, reviewable history — not one giant changeset. Discard files, mark viewed, open in your editor.
One stable preview
A single .test domain points at whichever workspace is active. Switch worktrees; the URL stays the same.
Plain-markdown PRDs
PRDs are plain markdown — write them in any editor, stored in .canopy/prds/ at the repo root. One feature, one workspace, one file.
No account, no telemetry
Nothing phones home. No Canopy account to create. No usage data collected. Your code and credentials stay on your machine, full stop.
MIT open core
The core is free and MIT licensed. Open an issue, start a discussion, or contribute a fix — built in the open from day one.
Git workflow built-in
Merge to base, open a PR, or reveal in Finder from the right rail. Local vs. base diff toggle. Per-commit viewer. No terminal context-switching.
Start the loop.
Steer from anywhere.
Pro adds a browser layer over the same local executor. Your machine does the building — you monitor progress, approve gates, read diffs, and queue the next spec from any network. The loop runs the same either way.
Monitor running loops
See every workspace's live status — what task it's on, what the agent just committed — from a browser tab on any network.
Approve a permission gate
When the agent pauses for confirmation, a notification reaches you wherever you are. Unblock it from your phone or a café. The machine keeps building.
Read a diff
Pull up the unified diff for any workspace from the browser. Review what's been built, mark files viewed — no SSH, no terminal required.
Queue a PRD
Drop a new spec into a workspace from the browser. Your machine picks it up and starts the next loop automatically.
Your machine stays the executor. Pro is the remote window into it — not a cloud replacement, not a crippled-free gate.
Free where it matters most.
The boundary is the network. Everything on one machine is MIT licensed, fully functional, and free — forever. Pro is the relay that lets you reach it from anywhere else.
MIT licensed. Free forever.
The entire on-device experience — every workspace, every loop, every git worktree — is MIT licensed and fully functional on a single machine with no seat count, no expiry, and no crippled features. Free means free.
Your code never leaves the machine.
Reflinks, agent credentials, and source code all stay local. The relay forwards end-to-end-encrypted frames and holds only ciphertext — it cannot read your code, your tokens, or what the agent is building.
Honest about the limits.
Remote access requires the machine to be awake and online. If it isn't, you see a machine-offline state — not a spinner that times out. The relay and client are open-source; self-host the relay if you prefer.
Canopy built Canopy.
The alpha desktop app ran the PRDs that shipped the next version of the desktop app. A human wrote the spec — Canopy picked it up, looped autonomously, and committed the work one task at a time. The relay, the web client, and this site followed the same pattern. Every part of the product was built by the product.
The desktop app
The alpha Canopy ran the PRDs that shipped the next version of Canopy. The loop building features was itself running on Canopy.
The relay
The Pro relay — the bridge between machine and browser — was specced as a PRD and shipped by the same autonomous loop.
The web client
The browser interface for monitoring loops, approving gates, and queuing work was built by Canopy, one commit per task.
This site
This marketing page was implemented from a set of PRDs. Canopy built each section — components, layout, copy — from those specs.
A human still authors the PRDs and reviews the output. Not fully hands-off — but the building is real and autonomous.
One loop becomes
a canopy.
Download for macOS, drop in a PRD, and watch your first autonomous loop run. Then open a second workspace and go wide.