Inspiration
ChatGPT is a powerful place to explore ideas, but learning rarely follows a straight line. One question reveals several new concepts, each concept leads to another conversation, and before long an entire field is spread across dozens of chats.
ChatGPT’s built-in Projects already help group related conversations, but grouping is not the same as understanding how ideas connect. A project can contain many chats without showing which answer introduced a concept, which questions remain unexplored, or how each discussion contributes to a larger understanding.
We still found ourselves reconstructing those relationships manually and moving important takeaways into a separate notes tool. The conversations were together, but the learning structure remained implicit—and the knowledge we wanted to keep still lived somewhere else.
That led us to a different question: what if every answer could become a map of what to explore next, and that map lived directly inside ChatGPT?
ChatNotion brings the complete learning loop into one place: ask, structure, explore, branch, annotate, and continue building on what you understand.
What it does
ChatNotion turns a ChatGPT answer into a map of what to learn next. Unlike a traditional chat organizer, its tree does not merely display conversations that already exist. Each unexplored node represents a possible next question, and each explored node can become an editable knowledge page.
Built for students, researchers, and curious minds, ChatNotion turns open-ended conversations into structured, evolving knowledge—so you can explore any field systematically and build expertise faster.
Explore. When an answer is complete, click Generate tree to transform its key concepts into an expandable knowledge tree. Open any node, and ChatNotion starts a focused conversation with the question and relevant parent context already prepared in the composer. If the original answer lacks sufficient structure, Tree Mode guides ChatGPT to produce a tree-ready response.
Keep. Open any explored node as an editable knowledge page. Distill the answer to its most useful ideas, highlight important passages, and add your own notes while keeping the original ChatGPT conversation one click away.
Organize. Arrange conversations and knowledge pages into nested structures that reflect how ideas connect—not merely where the chats are stored. Drag, drop, reorder, multi-select, and batch-move items, with Undo and Redo for every change. When you use ChatGPT’s native branching feature, ChatNotion recognizes the relationship and places the new conversation beneath the chat it came from.
Everything—your knowledge tree, captured answers, edits, highlights, and backups—remains locally on your device. ChatNotion requires no separate account, uses no developer-operated server, and includes no tracking.
ChatNotion is currently under review for the Chrome Web Store. In the meantime, judges can install the packaged build using Chrome’s Load unpacked option for testing (Github).
How we built it
ChatNotion is a Manifest V3 Chrome extension built with plain JavaScript, CSS, and browser-native APIs. It uses no framework, bundler, backend, or external data service.
The extension runs across three connected areas:
- A content script renders the ChatNotion panel inside an isolated Shadow DOM, keeping its interface largely independent from ChatGPT’s styles. It adapts to the live ChatGPT interface, renders the knowledge tree, and handles drag-and-drop, selection, editing, and other user interactions.
- A background service worker manages durable storage, compact Undo and Redo history, cross-tab synchronization, import and export, and scheduled backups through
chrome.alarms. - A separate backup page handles the explicit browser permission required to save automatic backups to a user-selected local folder.
We divide storage according to the weight of the data. Lightweight workspace structure, preferences, and history metadata live in chrome.storage.local. Larger node documents and captured conversation snapshots live in extension-owned IndexedDB and are loaded only when needed.
The data model is versioned and includes migrations, allowing older workspaces to upgrade without losing their content. Deleting a ChatNotion node never deletes the corresponding ChatGPT conversation, and editing a knowledge page never modifies its source.
Where possible, we separated browser-dependent behavior from pure, testable logic. Markdown tokenization, math parsing, outline extraction, prompt composition, tree operations, history patches, and backup validation are implemented as independent modules that can run directly in Node tests.
ChatNotion has no backend and makes no requests to a developer-operated service. Its extension-owned pages use a restrictive Content Security Policy, and all workspace data remains under the user’s control.
We built ChatNotion through an iterative conversation-to-code workflow with Codex and GPT-5.6. Each feature followed a repeated cycle: define the desired behavior, inspect the existing system, implement a focused change, test it inside ChatGPT, report failures, and convert those failures into regression tests.
Codex was not used only to scaffold the extension. It helped separate browser-dependent code from testable modules, design the versioned storage model, diagnose the KaTeX duplication problem, implement compact history patches, harden local persistence, and translate failures from manual ChatGPT testing into automated tests.
We directed the product vision, feature priorities, interaction design, and manual testing. Through this process, ChatNotion grew from a simple organizer into a local-first learning workspace connecting exploration, contextual follow-up conversations, note-taking, and knowledge retention directly inside ChatGPT.
Challenges we ran into
ChatGPT is a moving target. Messages stream gradually, controls appear at different moments, and navigation often occurs without a full page reload. We had to determine when an answer was genuinely complete before showing Generate tree, while avoiding partial or stale messages.
Conversation identity is slippery. Different chats can share the same title, URLs can change during branching, and a branch of a branch must remain under its immediate parent rather than jumping back to the root. We built URL-based identity, pending-branch coordination, and repair logic to preserve those relationships.
Tree extraction must work without another AI service. ChatNotion generates its knowledge tree locally by parsing headings, lists, and structural patterns in the answer. This keeps the workflow private and immediate, but loosely structured prose can be difficult to interpret. We introduced Tree Mode to help ChatGPT produce answers with clearer conceptual structure when needed.
Math kept smearing. ChatGPT’s KaTeX output contains MathML, the original TeX annotation, and visual HTML. Reading its text naively concatenated several representations of the same formula. We now extract the original TeX annotation, store clean $…$ and $$…$$ expressions, and render them with KaTeX’s HTML output. The result is valid, clean, and copyable mathematics.
Keystrokes leaked into ChatGPT. ChatGPT’s page-level keyboard and focus handlers sometimes intercepted text intended for a ChatNotion folder name or note field. We built an input-isolation layer so editing inside ChatNotion does not interfere with the ChatGPT composer.
No server means no safety net. A local-first product must earn durability through careful engineering. We added migrations, validated restore, manual and rotating automatic backups, cross-tab synchronization, and dependable Undo and Redo.
Accomplishments that we're proud of
We’re proud that ChatNotion turns a linear conversation into a complete learning loop. An answer becomes a map of possible next questions, each branch can become a contextual follow-up conversation, and every explored idea can become an editable knowledge page.
Much of the work we are proudest of is nearly invisible. ChatNotion waits until a streamed answer is genuinely complete, preserves the correct parent across branches of branches, prevents ChatGPT’s keyboard handlers from disrupting extension inputs, migrates older workspaces safely, and captures formulas without duplicating KaTeX’s hidden output.
We also built ChatNotion as a durable product rather than a disposable prototype. It has a versioned data model, IndexedDB-backed document storage, cross-tab synchronization, compact Undo and Redo history, validated local backups, and 162 automated tests.
The tests cover migrations, tree operations, Markdown and math parsing, prompt composition, synchronization, backup validation and rotation, selection behavior, and answer-state detection.
Most importantly, all of this works without a separate ChatNotion account, backend, analytics service, or developer-operated data store. Privacy comes from the architecture, not only from a policy statement.
What we learned
We learned that organizing AI conversations is a relationship problem, not simply a folder problem. Projects and folders can place related chats together, but they do not automatically reveal how one idea led to another or what should be explored next.
Questions create more questions. Broad topics divide into focused ones, and people return to earlier branches with new understanding. A knowledge tree is therefore more than a visual arrangement of existing chats—each node can be a live entry point into the next conversation.
We also learned that privacy is an architectural decision. Removing the backend made trust simpler, but it demanded stronger local persistence, migration, backup, and recovery systems.
Finally, we learned that integration quality lives in the details. Waiting for the right moment, preserving conversation identity, isolating input events, separating DOM-dependent behavior from testable logic, and making Undo dependable mattered just as much as generating the tree itself.
What's next for ChatNotion
- Publish the extension on the Chrome Web Store and continue hardening its integration as ChatGPT’s interface evolves.
- Improve knowledge-tree extraction for loosely structured answers.
- Capture images locally so they remain available after their source URLs expire.
- Extend the learning-tree workflow to other AI platforms while preserving one user-controlled map of how conversations and ideas connect.
Our long-term goal is for ChatNotion to be the all-in-one workspace for AI conversations — no matter which model or platform they come from — turning scattered discussions into one organized, explorable, fully user-controlled knowledge system.
Built With
- chrome
- codex
- css3
- gpt5.6
- html5
- javascript
- manifest-v3
- node.js
Log in or sign up for Devpost to join the conversation.