Introducing Canopy: Self-Hosted Code Intelligence for AI Coding Agents

Note: Canopy is in pre-release development. Purchase and download links aren’t live yet. Join the waitlist to be notified at launch.

This is our first public look at what we’re building. Canopy is not yet available for purchase or download — the waitlist gets the email the moment it is. But the product is real: Canopy 2 builds and runs today on Linux, macOS, and Windows, and we want developers who work with AI coding agents every day to know what it does.

AI coding agents have a structural problem: they are brilliant at reasoning but nearly blind to your codebase. They guess at import paths, miss dependencies, and leave stale references behind. This is not an LLM failure — it is a context failure. Canopy fixes it.

The Problem Agents Have

Ask any AI coding agent to “refactor the authentication flow” in a medium-sized codebase and watch what happens. It reads a few files it thinks are relevant, makes changes, and hands them back. What it misses: the 14 other files that import the function you just renamed. The test suite that will break. The integration in the dashboard that nobody updated the docs for.

The agent is not dumb. It just does not have a dependency graph. It does not know what depends on what. It is pattern-matching on filenames and grep results, which is better than nothing but consistently wrong in specific, painful ways:

• Broken imports — a renamed symbol updated in 3 of 5 call sites, silent at write time, loud at runtime
• Dead exports — a removed function that three other modules still import
• Stale types — TypeScript interface changed in the source, not updated in the callers
• Circular dependencies — introduced silently during a refactor, shows up as a cryptic error at build time

These are not edge cases. If you use an AI agent daily on a real codebase, you have hit all of them.

What Canopy Is

Canopy is a single Rust binary that indexes your codebase and exposes one MCP tool — canopy_answer — to your AI coding agent. Behind that one call sits a structural index built at the AST level: what each file exports, what each file imports, which symbols are used where, and which dependencies form cycles. It ingests SCIP for compiler-precise analysis, ingests test coverage, and ingests git history, so ownership questions have answers too.

When your agent connects to Canopy via MCP, it stops guessing and starts asking. Instead of reading 40 files, it asks ‘what depends on src/utils/payments.ts?’ and gets a precise, cited list. Instead of hoping a refactor is safe, it asks ‘what should I know before editing src/core/license.rs?’ and gets the pre-edit dossier — dependents, test coverage, ownership, wiring — before touching anything. A deterministic router (360/360 on its labelled regression corpus, no LLM call, no network) maps each question to the right recipe and runs the whole chain server-side. One call in, one cited answer out.

Key facts about Canopy:

• Single static binary. One file. No runtime dependencies. Ships for Linux x86_64/ARM64, macOS x86_64/ARM64, and Windows x86_64.
• One MCP tool. Canopy v1 exposed a 31-tool catalog; v2 replaced it with a single routed call, because our own control benchmark showed agents orchestrating a tool catalog spend 2.3×–5.8× more than agents with plain shell tools. Phrasing picks the recipe — locate, extract, explain, dependents, imports, ownership, coverage, wiring, architecture — and when nothing clears the relevance floor, Canopy says “no strong match” instead of relaying tangential files.
• Benchmarked, independently graded. Across a 270-question suite on three OSS repositories, Canopy-assisted agents scored 0.932 vs 0.530 correctness against a shell-tool baseline (+76%) while using 69% fewer tokens per question — roughly 5× cheaper per correct answer.
• Runs locally. Your code never leaves your machine. The index lives in ~/.canopy/.
• License validation with weekly health check. Ed25519 cryptographic signature verification — no network call to activate. A weekly hash-only heartbeat validates your license server-side and enables revocation on refund/dispute. See our privacy policy for exactly what is transmitted (spoiler: just your license hash, client version, and platform — never code or queries).
• 55+ languages & formats indexed. Rust, TypeScript, JavaScript, Python, Go, Java, Kotlin, C, C++, C#, Swift, Ruby, PHP, and dozens more — symbols and imports in one index.
• Community mode. Free: the full local AST + full-text index, keyword answers through canopy_answer, and the MCP server. Paid tiers add semantic search — the answer-quality lever — plus the dashboard, CI mode, and team features.

Who It Is For

Canopy is built for solo developers and small teams (3-10 people) who use AI coding agents every day and care about keeping their source code off of cloud infrastructure.

If you are running Claude Code, Cursor, Codex CLI, Windsurf, Zed, or anything that speaks MCP — Canopy plugs directly into your workflow. You install it once, run canopy setup once — it wires every detected MCP editor and indexes the repo in seconds to minutes depending on repo size (see /benchmarks) — and from that point your agent knows what it is working with.

You are a good fit if you:

• Find yourself cleaning up after AI agents that miss call sites
• Work on a codebase large enough that agents cannot read it all at once
• Work in a regulated environment where code cannot leave your network
• Are tired of credit-based pricing models where a large context window empties your account

You are probably not the right fit yet if you need enterprise features (SSO, audit logs, SLAs) or want a bundled AI model alongside the context engine — Canopy is a context engine, not an agent.

What Canopy Does Not Do

To be direct:

Canopy does not ship an LLM. It gives your existing agent better context. Canopy does not run as a hosted service. It runs on your machine. Canopy does not collect telemetry or analyze your code. The only data that leaves your machine is a weekly license health check (hash only, never code — see privacy policy).

Pricing (at launch)

All paid tiers will start with a 14-day free trial — full features of your chosen tier, card required upfront, no charge until day 15. Cancel anytime via the customer portal.

Annual is the better math for daily use — Solo annual works out to $16.58/month.

What to Expect at Launch

When Canopy launches, setup is three commands:

canopy setup      # license → local embeddings → MCP wiring → index
canopy doctor     # am I ready? license, index, active backend, data flow
canopy answer "what should I know before editing src/auth/session.ts?"

1. Download the binary for your platform. No account required.
2. Run canopy setup inside your repository. One command walks the entire onboarding — license, local embeddings, summary backend, cache — then wires every detected MCP editor (Claude Code, Cursor, Zed, and friends) and indexes the repo. canopy setup --yes runs it with zero prompts.
3. Start a session and ask your agent about a refactor. Watch it ask ‘what depends on …?’ before touching anything.

Beyond the Core

The one-call surface is the product. Around it:

• Dashboard — canopy serve --dashboard renders the dependency graph and index health in a local web UI (Solo and up)
• CI mode — canopy ci brings the same answers to pipelines, with annotations and SARIF output (Pro)
• Team surface — shared team configs, an admin portal, and a CI index cache on R2 or your own S3 (Team)

Stay in the Loop

If you are building with AI agents every day, we would like to know what problems you are hitting. The best way to follow development is GitHub Discussions or email support@gulfshieldtech.com.

Join the waitlist at canopy.gulfshieldtech.com — we’ll email you when Canopy is available.