Ever deep-dived into a topic with ChatGPT, only to have one stray tangent pollute your entire conversation? You ask a follow-up, and suddenly the LLM forgets the plot because an irrelevant digression contaminated the context. The standard fix? Open a new chat, paste in the history manually, and pray. That's not a solution — it's surrender. I wanted real branches, not tabs. Branches that inherit the right context automatically and stay isolated. So I built ContextTree, a visual node-based canvas that rethinks how we interact with LLMs. Here are the ten things you need to know about this paradigm-shifting tool.
1. The Core Pain: One Tangent, One Wrecked Thread
Every deep dive with an LLM feels like walking a tightrope. You ask a clarifying question, and suddenly the assistant veers off into tangents like a dog chasing squirrels. The conversational context becomes a messy stew of relevant and irrelevant data. The classic coping method — copying your chat history into a brand new thread — is manual, error-prone, and drains your creative flow. ContextTree solves this by making branches a first-class action. No more context contamination; each branch lives in its own clean room, so your conversation stays sharp and focused.
2. What Is ContextTree? A Node-Based Visual Canvas
Imagine a whiteboard where every message you send is a node. You can fork off from any node to start a new line of thought, and that branch inherits only what it needs — never the side conversations or cousin threads. This visual graph makes exploration natural. Instead of parallel tabs or separate chat windows, you see your entire thought map in one place. The canvas grows organically, each node a self-contained conversation bubble. You can zoom, pan, and click to jump into any branch without losing your place. It’s like having a mind map come alive with an AI assistant.
3. Each Node Carries Its Own LLM Model
One of ContextTree’s killer features: you can assign a different LLM to each node. On one branch, you might use GPT-4o for creative brainstorming; on another, Gemini Flash for lightning-fast fact checks. The model sticks to that node and its children — no cross-model contamination. This means you can run a cost-sensitive summarizer on one fork and a deep-reasoning expert on another, all within the same canvas. No need to juggle separate app tabs or remember which model you used where. The canvas remembers for you.
4. Custom System Prompts Scoped to Each Node
System prompts shape an LLM’s personality. In most chat UIs, you get one system prompt per thread. In ContextTree, every node can have its own system prompt, and that prompt is inherited by its children — unless you override it. For example, you could start with a general assistant, fork a “legal persona” branch with a strict “only cite statutes” prompt, then fork again into a “creative writer” with a completely different tone. Each branch behaves like a specialized agent, yet they all live on the same graph. No more copy-pasting prompts into new chats.
5. Granular Control Over Advanced Settings
Beyond models and prompts, each node carries its own temperature, max output tokens, history mode, last K messages, context budget in tokens, and even external context chunk count. Want a high-temperature brainstorm on one leaf and a low-temperature precise answer on another? Done. The advanced settings are per-node, so you can fine-tune the LLM’s behavior for the exact task at that point in the conversation. This level of granularity is unheard of in standard chat interfaces — it puts you in the driver’s seat.
6. The Context Inheritance Principle: Knowledge, Not State
The hardest design decision was how context flows between nodes. Here’s the rule: a child node never reads its parent’s live state — no shared LangGraph state, no reading the parent’s current summary after the fork moment. Each node evolves independently. However, ancestry-scoped vector search lets a child retrieve relevant snippets from any ancestor’s history, capped at the fork point. Branches inherit knowledge, not state. This distinction took time to nail, but it makes the architecture clean. If you want hard isolation, just set SIMILAR_CONTEXT_LIMIT=0 per node.
7. Visual Clarity: See Your Conversation Forest, Not Just Trees
Most LLM UIs are linear — a scroll of messages. ContextTree turns your conversation into a tree you can see. You can instantly spot where branches diverge, which nodes have high token budgets, and where you might want to prune. The visual graph is not just pretty; it’s functional. You can collapse branches you’re done with, zoom into active nodes, and even annotate nodes with notes. This design makes it easy to revisit a line of reasoning weeks later — just look at the graph and pick up where you left off.
8. Still Figuring Out: Prompt Stack Order and RAG Pinning
No tool is perfect, and ContextTree is early stage. Two open questions: prompt stack order — should users reorder layers of prompts (system, user, tool)? And RAG sources — should each node be able to pin different documents? The current version already supports per-node RAG, but the UX for managing multiple knowledge bases is under design. These features could turn ContextTree into a full-blown multi-agent orchestration platform. The developer is actively seeking feedback, especially from those building prompt engineering tooling.
9. Demo and Video Walkthrough Available Now
You don’t have to take my word for it. There’s a live demo at CONTEXTTREE and a video walkthrough on YouTube. The video shows branching in action — creating a node, forking, changing models mid-conversation, and seeing the context isolation work. The demo is free to play with. It’s built solo, early stage, so be gentle but brutally honest. Feedback is the fuel for improvement.
10. Why This Matters: The Future of LLM Conversations
Most AI interactions today are disposable — one query, one answer, then start over. ContextTree imagines a world where conversations are living documents, trees of thought that grow over time. Each branch can become a distinct agent persona, a research thread, or a creative exploration. The underlying principle — knowledge inheritance without state contamination — could influence how future LLM interfaces are built. Whether you’re a developer, a writer, or a researcher, ContextTree offers a new way to think with AI, not just talk at it.
Conclusion: ContextTree is more than a tool; it’s a philosophy shift in LLM interactions. By isolating branches, scoping models, prompts, and settings per node, it solves the context contamination problem once and for all. The visual canvas makes complex explorations manageable, and the thoughtful inheritance design keeps your threads clean. It’s still early, but the foundation is solid. Try it, break it, and tell the builder what you find. The future of conversational AI might just be a tree.