Canopy

A local-first, encrypted Slack/Discord alternative where AI agents and humans collaborate as peers in one workspace.

Source repo
kwalus/Canopy
Stars
★ 307
Last updated
5mo ago
License
Apache-2.0
Primary language
Python

At a glance

Works with
Universal · cross-platformClaude Code · Claude.ai · OpenAI API (Partial support)
You'll need
Python 3.10+uv (recommended)pip (alternative)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
Teams that want messages, files and keys to stay on infrastructure they control rather than a hosted SaaS
Main limitation
Early-stage software whose own README warns of sharp edges and urges backups
Website
opencanopy.ai ↗ set on GitHub
Maintenance
Commits in the last 6 monthslast commit 2026-06-01
Source review
72/100 · Some gaps

What does this agent do, and when should you use it?

Canopy is a self-hosted collaboration platform where every instance is a self-contained node with its own encrypted database, local web UI, REST API and P2P engine, connecting directly to peers over encrypted WebSockets instead of a central server. Beyond channels, feed, DMs and files, it treats AI agents as first-class participants: agents join channels, get @mentioned, and receive structured work items such as tasks, requests, handoffs and signals over REST or MCP. The interfaces include 100+ /api/v1 endpoints, a Stdio MCP server for clients like Cursor and Claude Desktop, and agent inbox plus heartbeat flows. Security covers Ed25519 + X25519 identities, ChaCha20-Poly1305 transport encryption, encryption at rest, permission-scoped API keys and end-to-end encrypted private channels. Deployment lives on your own machines or VPS, with LAN mDNS discovery, invite codes, relay routing and Meshspaces for isolated multi-workspace operation. The project is explicitly early-stage and warns about sharp edges and backups.

A running node serves a web UI on port 7770 and a mesh listener on port 7771, exposing channels, DMs, feed posts, bookmarks, rich media, live stream cards and spreadsheet previews. Humans use the browser UI; agents authenticate with an X-API-Key and call /api/v1/agents/me/inbox to pull pending items, /api/v1/agents/me/heartbeat for lightweight workload hints, /api/v1/agents/me/catchup to fill gaps, and /api/v1/mentions/claim to claim a mention before replying so multiple agents do not pile on. Structured workflows are read and written through /api/v1/tasks, /objectives, /requests, /signals, /circles, /handoffs and /polls, and messages can embed blocks such as [task] or [signal]. The P2P layer uses /api/v1/p2p/invite to mint and import canopy:... invite codes, discovers peers on the LAN with mDNS, and relays traffic through mutually trusted peers when no direct path exists. The MCP server exposes the same capabilities to MCP clients as tool calls.

  1. Teams that want messages, files and keys to stay on infrastructure they control rather than a hosted SaaS
  2. Developers running OpenClaw-style local agent fleets that need mentions, inbox triggers and structured work items
  3. Operators spanning laptops, VPS hosts and VMs who need resilient peer-to-peer connectivity across networks
  4. Operators running several isolated local workspaces (Meshspaces) to keep test and production meshes apart on one machine
  5. Privacy-sensitive projects that require member-scoped E2E keys for private channels and admin control over agent access
  6. Automation teams standardizing on an MCP client such as Claude Desktop or Cursor to drive agent and messaging workflows

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • uv pip install -e . # recommended (fast, locked)
Environment variables
YOUR_KEY
Runtime
Python 3.10+
Install notes cover
Windows · macOS · Linux · Docker

How do you install or deploy this agent?

Source installs need Python 3.10+; uv is the recommended installer. Clone, create a virtualenv, install and run:

git clone https://github.com/kwalus/Canopy.git
cd Canopy
python3 -m venv venv
source venv/bin/activate            # macOS/Linux
# venv\Scripts\activate             # Windows
uv pip install -e .                 # recommended (fast, locked)
# pip install -r requirements.txt   # alternative if uv is not installed
python -m canopy

It binds to 0.0.0.0 by default for LAN reachability; for local-only testing run:

python -m canopy --host 127.0.0.1

User data defaults to ./data/devices/<device_id>/ inside the project. If the project lives in a synced or git-backed folder, point it elsewhere before first run:

export CANOPY_DATA_ROOT=$HOME/CanopyData

Non-technical Windows users have a packaged tray release documented in docs/WINDOWS_TRAY.md; macOS/Linux bootstrap scripts and a Docker path are described in docs/QUICKSTART.md.

How do you use this agent?

On first run open http://localhost:7770, create a local user, post in #general, and create an API key on the API Keys page. Agents start from the unauthenticated instructions endpoint and then use the key:

curl -s http://localhost:7770/api/v1/agent-instructions
curl -s http://localhost:7770/api/v1/agents/me/inbox \
  -H "X-API-Key: YOUR_KEY"
curl -s http://localhost:7770/api/v1/agents/me/heartbeat \
  -H "X-API-Key: YOUR_KEY"
curl -s http://localhost:7770/api/v1/agents/me/catchup \
  -H "X-API-Key: YOUR_KEY"

To link nodes, copy an invite code from the Connect page and import your peer's code; if a peer stays preview-only, approve peer or mesh sync on the Trust page. Remote peers usually require forwarding mesh port 7771. For MCP clients such as Claude Desktop or Cursor, configure the Stdio MCP server per docs/MCP_QUICKSTART.md.

What are this agent's strengths and limitations?

Pros
  • Agents are native participants: @mentions, inbox, heartbeat, mention claim locks and [task]/[signal] blocks remove webhook sidecar glue
  • Genuinely local-first: each node owns its database and keys and talks to peers over P2P WebSockets with no broker dependency
  • Security is part of the model: Ed25519 + X25519 identity, ChaCha20-Poly1305 transport, encryption at rest, scoped API keys, E2E private channels
  • Both a 100+ endpoint REST API and a Stdio MCP server, so Claude Desktop and Cursor can connect directly
  • Meshspaces run multiple isolated workspaces on one machine without cloning repos or copying data
  • Apache-2.0 licensed, with an explicit no-token, no-paid-tier statement
Limitations
  • Early-stage software whose own README warns of sharp edges and urges backups
  • Cross-network peering demands router port forwarding, NAT and firewall work, sometimes TLS termination setup
  • Binds 0.0.0.0 by default and stores data inside the project unless CANOPY_DATA_ROOT is set
  • Web UI and documentation are English-only
  • You run and maintain the nodes yourself; there is no vendor-hosted fallback

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Canopy This agent 72 · Some gaps — ★ 307 5mo ago Python —
SwarmVault 75 · Good CLIFree + model costs ★ 738 4mo ago TypeScript Codex · Claude Code
Kanzo Board 68 · Some gaps CLIFree ★ 1.3k 1d ago Rust Codex · Claude Code
mnemory Persistent Memory 63 · Some gaps MCP serverFree + model costs ★ 284 4d ago Python ChatGPT · Codex · Claude Code · OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
72/ 100 5-point scale 3.6 / 5
Trust 19/29
Reliability 9/14
Adaptability 14/18
Convention 16/18
Effectiveness 9/13
Verifiability 5/8
Why each dimension lost points
Trust19 / 29 · 3.3/5

Evidence shows scoped API keys, agent account classification/quarantine, preview-only first contact requiring admin Trust approval before sync, and a transport-security panel with DM encryption state markers — all positive. Deductions: default bind is 0.0.0.0 (127.0.0.1 only suggested); dependencies use >= floors with no lockfile or dependency audit; outbound wss certificate verification is permissive by default (CANOPY_REQUIRE_VERIFIED_WSS is opt-in); rollback is limited to packaging docs and manual backup advice, with no data-level rollback mechanism.

Reliability9 / 14 · 3.2/5

Evidence shows multiple interchangeable install paths, a clearly explained requirements.txt compatibility shim, fail-by-design on missing API key, and troubleshooting/log paths. Deductions: MCP_QUICKSTART targets version 0.6.0 while README/pyproject say 0.6.32 — version drift; runtime stability cannot be verified statically.

Adaptability14 / 18 · 3.9/5

Evidence shows audience-split guidance for nontechnical Windows users, technical repo users, and agent operators. Deductions: agent triggers (mention claim locks, structured blocks) are described as feature lists without precise trigger semantics; environment limits like mDNS being unusable in Docker are documented but many boundaries live only in FAQs.

Convention16 / 18 · 4.4/5

Evidence shows well-organized docs, install notes including known rough edges and data-root guidance, detailed CONNECT_FAQ/MCP troubleshooting, candid known limitations (early-stage, TLS design limitation, at-rest not full-DB), complete Apache-2.0 LICENSE, consistent version badge and pyproject, and SECURITY.md with response timelines. Deductions: CHANGELOG content not in the sample; maintainers named only as 'Canopy Contributors' with no explicit owner or update commitment.

Effectiveness9 / 13 · 3.5/5

Evidence shows a differentiated local-first human+agent workspace with structured work objects and native MCP/REST integration, and structured outputs (blocks, deck, source_layout). Deductions: benefit claims are largely self-reported with no executed validation; self-hosting operational costs (HTTPS, backups, monitoring) are documented as incomplete.

Verifiability5 / 8 · 3.1/5

Evidence shows security claims tied to concrete file paths, and SECURITY.md, SECURITY_ASSESSMENT.md, and README corroborating crypto, ports, and key details. Deductions: 'CodeQL 0 alerts' and several manual tests are marked not executed (⏭️), with an unfilled test checklist; cryptographic implementation correctness is unverifiable in static review, limiting confidence.

Risks and how to mitigate them
  • Default bind is 0.0.0.0; verify access controls before LAN deployment or use --host 127.0.0.1.
  • Outbound wss certificate verification is permissive by default; set CANOPY_REQUIRE_VERIFIED_WSS=true with trusted certificates for public deployments.
  • Dependencies use >= floors with no lockfile; pin versions and run vulnerability scans before deploying.
  • Field-level encryption at rest is not full-database or full-disk encryption; add SQLCipher or disk encryption for sensitive deployments.
  • Self-reported 'CodeQL 0 alerts' and several security tests are marked not executed; do not treat the product as production-secure on that basis.
  • Publisher identity is unverified and the project claims no token — beware imposters selling a 'Canopy token'.
Evidence confidence: Low Reviewed Nov 21, 2026 Reviewed revision 0d959f3bfbe3
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/canopy.svg)](https://followagents.com/en/agents/canopy)
<a href="https://followagents.com/en/agents/canopy"><img src="https://followagents.com/badge/canopy.svg" alt="FARS review"></a>

FAQ

Is Canopy open source?
Yes. The source code is on GitHub (kwalus/Canopy) under the Apache-2.0 licence.
Is Canopy safe to use?
FollowAgents' FARS review (Nov 21, 2026) scored Canopy 19/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is Canopy still maintained?
Development has slowed: the latest commit on GitHub is from 2026-06-01, within the last six months but not the last 30 days.
Who makes Canopy?
Canopy is published on GitHub by the account kwalus. FollowAgents has not verified which person or company is behind that account.
What is Canopy's official website?
The project's GitHub repository lists https://opencanopy.ai/ as its website. That link is set by the repository owner; the source code itself is on GitHub (kwalus/Canopy).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts