CODECANOPY

A Codex engineering orchestration plugin

The smallest verified tree that reaches the goal.

CodeCanopy is a Codex plugin that turns an engineering goal into the smallest dependency-ready tree of agents. One lead keeps scope, integration, and the final verdict; work comes back upward with evidence.

  1. Root lead
    1. Architecture parent
      1. Dependency-ready leaf
  2. Root accepts integrated evidence
Install CodeCanopy View on GitHub

Install

codex plugin marketplace add adhit-r/codecanopy --ref main codex plugin add code-canopy@codecanopy
A bounded ownership route

Illustrative route shape, not live task status. Parents integrate; dependency-ready leaves produce the evidence they need.

  1. Lead Root Own scope, integration, and final verdict User goal
    1. Parent Architecture Define contracts and artifact dependencies Root scope
      1. Leaf Contract State the interface and acceptance boundary Architecture
      2. Leaf Evidence Define a runnable proof for the agreed boundary Contract
    2. Parent Implementation Integrate scoped, owned changes Contract artifact
      1. Leaf Backend Deliver one source change and runnable check Contract artifact
      2. Leaf Interface Deliver the dependent client change and check Backend artifact
    3. Leaf Review Inspect the integrated diff and its evidence Integrated parent
Goal Root acceptance with integrated evidence

Execution sequence

  1. Leaf testKeep one agent when one bounded deliverable and acceptance check are enough.
  2. Critical frontierDispatch only the smallest ready work that can advance the next proof.
  3. Parent acceptanceVerify required artifacts and evidence before a result moves upward; only the root performs Git integration.

Configuration

An optional project-root .codecanopy.toml may lower or tune these planning limits. It cannot grant authority.

schema_version = 1
runtime = "codex"

[tree]
max_depth = 3
max_children_per_node = 3
max_total_nodes = 9
max_parallel = 3
max_replans = 1

[budget]
root_reserve_percent = 35
retry_limit = 1

[models.lead]
reasoning_effort = "high"

Safety boundary

CodeCanopy's root creates and verifies isolated worktrees where needed. Codex and its host enforce only their documented sandbox, approval, model-availability, and concurrency boundaries.

Delegation never expands a user's authority. Remote writes, destructive actions, credentials, production changes, and scope expansion still require explicit approval.

A direct definition, not a swarm promise.

CodeCanopy is free and open source under the MIT License. It helps a lead turn a non-trivial engineering requirement into the smallest useful ownership tree, order work through artifact dependencies, and integrate verified results bottom-up.

Bounded route versus an unbounded swarm

QuestionCodeCanopyUnbounded swarm pattern
Who owns integration?One root leadMust be assigned separately
What may execute?Dependency-ready leavesAny work that is dispatched
How does work finish?Evidence is integrated bottom-upThe coordination rule is left to the team

Frequently asked questions

Does v0.2 support providers other than Codex?

No. v0.2 supports Codex only. A Claude adapter is tracked as future research, not a current capability.

Who creates and verifies isolated worktrees?

CodeCanopy's root does so where needed. The host enforces only its documented sandbox, approval, model-availability, and concurrency boundaries.

Can project configuration grant a new permission?

No. Configuration can tune planning limits and preferred model mappings, but it cannot grant Git, network, destructive, credential, production, or publication authority.

Build the public route with us.

Use the public issue tracker for current work, deployment follow-up, and carefully labeled future research.