Context Canopy

Why ContextCanopy?

The better an AI agent remembers you, the harder it becomes to leave.

Preferences, project history, vocabulary, decisions, working style, and long-term goals accumulate inside chats and provider memory. A better agent appears, but switching means teaching it who you are all over again. Your memory becomes accidental vendor lock-in.

ContextCanopy makes durable context user-owned infrastructure.

ContextCanopy does not move a model's hidden mind. It moves the durable context that should belong to you.

How portability works

 chats · exports · notes · research · decisions
                       │
              Capture / Learn / Distill
                       │
           ┌───────────▼───────────┐
           │  CONTEXTCANOPY CORE   │
           │ identity · knowledge │
           │ goals · rules · proof│
           └──────┬────────┬───────┘
                  │        │
            Attach + Sync  │
                  │        │
               Claude    Codex    future agents
               own role  own role  own role

The core has three explicit layers:

1. Evidence — immutable source material: conversations, papers, manuals, and exports.
2. Canonical context — atomic knowledge, preferences, decisions, and long-term directions with one owner, sources, relations, and honest freshness.
3. Host projections — shared user rules plus a distinct role for each agent, delivered through Agent Skills and a thin local MCP bridge.

It is closer to a passport for your context than a giant system prompt: portable identity and history, with each agent retaining its own job.

Proof, not promise

npm run smoke copies the seed Vault, starts one fresh MCP process as Claude, captures a disposable knowledge card, shuts that process down, then starts a second process as Codex. Codex must load the same common rules, keep a different role, discover the card, and read it back. The compiler runs before and after, and SHA-256 guards prove the original Vault stayed byte-identical.

{
  "success": true,
  "cross_agent_handoff": {
    "source_agent": "claude",
    "target_agent": "codex",
    "fresh_server_processes": 2,
    "shared_common_rules": true,
    "distinct_agent_profiles": true,
    "entry_found_by_target": true,
    "entry_read_by_target": true
  },
  "copied_vault_compiler_check": "passed",
  "live_vault_unchanged": true,
  "temporary_copy_removed": true
}

This proves the portable core across isolated local client lifecycles. It does not claim universal import from closed provider-native memory.

Quick start

Requirements

• Node.js 18+
• Python 3.10+ with PyYAML (python3 -m pip install pyyaml)
• GitHub CLI for the recommended private-template bootstrap
• Obsidian is optional; any Markdown editor works

1. Create a safe personal authority

Do this before adding personal information. The recommended path creates a separate private repository and clones it as your only writable origin:

gh repo create my-context-canopy --private --template YusenZhang0601/context-canopy --clone
cd my-context-canopy
git remote add upstream https://github.com/YusenZhang0601/context-canopy.git

gh repo view --json nameWithOwner,visibility
git remote -v

Confirm that visibility is PRIVATE and that origin points to your private repository. You can also use GitHub's Use this template button and select Private.

For a local-only setup, disable public pushes explicitly:

git clone https://github.com/YusenZhang0601/context-canopy.git
cd context-canopy
git remote rename origin upstream
git remote set-url --push upstream DISABLED
git remote -v

Never use a public fork as a personal Vault.

2. Install and verify

python3 -m pip install pyyaml
npm ci --prefix mcp
npm test
npm run smoke

The v1.0.1 MCP package is installed from this repository's mcp/ source; it is not advertised as an npm-published package.

3. Attach an agent

Open the repository root in a compatible agent and send:

Read AGENTS.md and skills/second-brain-attach/SKILL.md, then attach this host to ContextCanopy.
Do not write personal information until the private or local-only authority is verified.
Install the bundled Skills, configure the local MCP server, run the documented checks,
and finish with a fresh-session Doctor check. Report only what was actually verified.

What ships in v1.0.1

Skills: capture-knowledge, second-brain-attach, second-brain-sync, second-brain-learn, second-brain-distill, second-brain-climb, second-brain-doctor, second-brain-help.

MCP tools: search_knowledge, get_entry, list_entries, capture_from_conversation, get_common_rules, get_agent_profile, get_mountain_context, list_second_brain_skills, read_second_brain_skill.

What moves—and what does not

Where it fits

ContextCanopy is not trying to be another hosted vector-memory API or a LifeOS dashboard. Its center is migration of a person's governed context across independent agents.

See the dated project landscape for comparisons with Basic Memory, AgentCairn, Memorix, AMP, Mem0, Graphiti, Letta, LifeOS, and related work.

Validation

# Vault compiler, linter, and MCP tests
npm test

# Two-process cross-agent handoff on a disposable full-Vault copy
npm run smoke

# Package and dependency hygiene
cd mcp
node --check index.js
node --check lib/vault-writer.js
npm pack --dry-run
npm audit --audit-level=low

CI runs at the declared minimums: Node.js 18 and Python 3.10.

Honest limits

• Historical migration is guided and source-preserving; universal one-click provider import is not included.
• Every real host still needs its own fresh-session attachment proof.
• The canonical layer is plaintext, not encrypted storage. Use private remotes, filesystem permissions, encrypted backups, and secret hygiene.
• Search is intentionally simple in v1.0.1. Optional disposable indexes may be added later without replacing Markdown authority.

Project name and compatibility

ContextCanopy is the public brand. The v1 line retains second-brain-* Skill IDs and SECOND_BRAIN_* environment variables as compatibility namespaces.

Contributing

The most useful contributions are preview-first import adapters, fresh-host recipes, migration fixtures, adversarial filesystem tests, and simpler onboarding.

If memory lock-in has stopped you from trying a better agent, tell us which context source should move first. Read CONTRIBUTING.md, follow the Code of Conduct, and report vulnerabilities through SECURITY.md.

License

MIT © 2026 TonyRainforest.

Your agents are replaceable. Your context is yours.

Built by TonyRainforest · System Builder Connect complexity. Create order. Evolve continuously.