Context Tree / A First Tree product

Shared context for every coding agent.

Keep decisions, constraints, and ownership in Git. Every agent starts from the same task-relevant context.

Start with Context Tree View on GitHub

Context Tree Shared team context

Agent reads Task-relevant nodes
Agent work Code, plans, decisions
Review Agent Check, fix, verify
Updated Tree Next shared snapshot

Agents: Claude Code, Codex, and repo-aware agents
Review: Automated Review Agent
Source of truth: Markdown in Git
Team model: Human and agent owners

01 / The problem

Your agents should not start from zero.

Chat history and flat files hold fragments. The Tree gives every task the same durable starting point.

Without shared context

Session A Decisions disappear
notes.md Owners repeat corrections
Session B Each agent invents a different model

With Context Tree

One shared understanding
Task-relevant Tree nodes
Validated updates return to the Tree

Context Tree

Task-ready agent

docs/decisions/auth-rate-limit.md
+ Rationale: Preserve abuse controls
+ Owner: Platform Team
+ Related: security/auth.md

Less re-explaining. More continuity.

47.5 seconds · English narration · Captions and transcript included

02 / The Context Loop

See the Context Loop in under 50 seconds.

The agent reads the Tree, does the work, and the Review Agent validates, fixes, and updates the next shared snapshot.

Read the transcript

Coding agents move fast. Without shared team context, every task starts from zero.
First Tree turns systems, constraints, decisions, and ownership into durable team context.
For each task, it selects only the Context Tree nodes the coding agent needs.
The agent works from that shared understanding, producing the patch, tests, documentation, and rationale.
Then the Review Agent checks the outcome, fixes context drift, reruns verification, and distills durable changes automatically.
The validated update becomes a new canonical snapshot, shared with every connected agent.
So every completed task strengthens the shared context and gives the next agent a smarter starting point.
First Tree. Team context that compounds.

Start with Context Tree

03 / What it is

Context every agent can read and reason from.

Every node is human-readable Markdown in Git, organized by domain, ownership, and relationships.

Context Tree Markdown in Git

context-tree/
├── product/
│   ├── onboarding/
│   └── principles/NODE.md
├── system/
│   └── cloud/
├── security/
│   └── auth/
└── members/

product/principles/NODE.md Selected node

---
title: "Product principles"
owners: [product]
soft_links:
  - system/cloud
---
## Decision
Coding agents read only the Tree nodes
relevant to the task.

## Rationale
Shared context keeps implementation and
decisions aligned across agents.

Task-relevant reads: Agents load only the nodes the current task needs.
Explicit ownership: Every node names its human or agent owners.
Traceable updates: Git records each validated change to shared context.

04 / Compare + adopt

Git-native context, not another wiki.

Get task-relevant reads, source-backed updates, and explicit ownership in the workflow your agents already use.

Comparison of Context Tree, flat files, and Wiki or RAG approaches
Need	Context Tree	Flat files	Wiki / RAG
Task relevance	Tree nodes for the task	Whole file	Search-ranked
Change control	Traceable in Git	Ad hoc	Page workflow
Ownership	Per-node owners	File-level	Separate permissions
Agent updates	Validated automatically	Manual rewrite	Ingestion dependent

Open source

Use the CLI in your Git workflow

Keep Context Tree beside the repositories and agents your team already runs.

Explore on GitHub

First Tree Cloud

Add team setup and governance

Start in First Tree. Continue in your coding agent.

Start with Context Tree

05 / Questions

Context that outlives the task.

Best for teams running multiple agents, repositories, or workflows that depend on durable decisions.

Does this replace our coding agents?

No. It gives Claude Code, Codex, and other repo-aware agents the same durable team context.

What does the Review Agent do automatically?

It checks source-backed updates, fixes context drift, verifies the result, and writes the next shared snapshot.

Where does the context live?

In a Git repository as plain Markdown, with metadata for ownership and cross-domain relationships.

When does a team need a Context Tree?

When repeated explanations, multiple agents, or cross-repository decisions make a flat instruction file hard to trust.