Agent's Knowledge vs. Our Knowledge + Recommendations Based on Difference

GraphMyMind

Inspiration

We were frustrated by seeing us and our friends understand less and less dense technical material as we offload more of our lives to AI. We found that although AI _ boosts _ our productivity, it _ decreases _ our learning speed.

However, this does not have to be the case. Why not invest in agentic systems that allow the AI to turbocharge us in our learning journey? What if we can have a long context personal agent that understands us, that knows what we know, and can guide us towards the optimal learning step to take next?

This is why we made GraphMyMind.

What it does

A fundamental difficulty of personalization in learning is the long context interactions that learning involves, often spanning weeks if not months. GraphMyMind tackles this problem by creating a living map of learning. It tracks two parallel knowledge graphs: one representing everything Claude knows about a topic, and another tracking what you actually understand. The gap between these graphs reveals your exact learning needs.

When you start a learning session, the system automatically researches your topic, building a comprehensive knowledge graph. As you interact with Claude, every question, confusion, and breakthrough gets captured through event hooks. Your personal knowledge graph evolves in real-time, showing not just what you've been exposed to, but what you've actually internalized.

The magic happens in the delta - the space between what's available to learn and what you've mastered. Instead of generic study guides, you get personalized learning paths that respect prerequisites and cognitive load limits.

How we built it

We kept it deliberately simple. The core is a Python setup script that transforms any directory into a Claude Code learning workspace. It uses template based generation to create event hooks, commands, and configuration files.

The event capture system leverages Claude Code's hook architecture. Every SessionStart, UserPromptSubmit, and interaction gets captured and sent to our Node.js server. We parse these events to understand learning patterns - what concepts you're exploring, where you're getting stuck, how long you spend on each topic.

Knowledge graphs are stored as Mermaid diagrams, making them both human-readable and programmatically parseable. The server converts these into structured knowledge representations, calculates deltas, and generates learning recommendations. Complex Mermaid diagrams are sometimes hard to read, so we also provide an ASCII graph view.

The frontend is intentionally minimal; a single HTML file with embedded JavaScript. No frameworks, no build process. It polls the server for updates and renders knowledge graphs using Mermaid.js. Clean, functional, fast.

Challenges we ran into

Knowledge extraction was harder than expected. Our first attempts at parsing learning materials generated thousands of meaningless "concepts"; page numbers, random phrases, formatting artifacts. We had to develop intelligent filtering that could distinguish real educational concepts from noise.

Graph synchronization broke constantly. Claude would update its knowledge graph while the user graph was being modified, creating race conditions. We solved this with atomic file operations and server side conflict resolution.

The biggest challenge was managing cognitive load. Early versions would identify hundreds of knowledge gaps and try to teach everything at once. We learned to respect human limitations; no more than 3-5 new concepts per session, with proper prerequisite ordering.

Event hook reliability was tricky. Claude Code hooks need to be fast and fail gracefully. Our first implementation would occasionally hang, breaking Claude's operation. We rewrote it to use fire and forget HTTP requests with aggressive timeouts.

Accomplishments that we're proud of

The system actually works end-to-end. You can set up a workspace, start learning, and watch your knowledge graph grow in real time. It's not a prototype, it's something we use daily for our own learning.

The delta visualization is powerful. Seeing the exact gaps between what Claude knows and what you understand creates genuine "aha" moments. One user described it as "seeing my ignorance mapped for the first time."

We kept it simple. No authentication, no cloud services, no complex dependencies. Everything runs locally. The entire server is 600 lines of code. Setup takes one command. This simplicity makes it actually usable.

What we learned

Learning is fundamentally about connections. Individual facts don't matter - relationships do. Understanding malloc requires understanding pointers, which requires understanding memory addressing. These dependency chains are everywhere.

Event driven architecture is perfect for education technology. Every interaction is a learning signal. By capturing everything, we can reconstruct not just what was taught, but how understanding evolved.

Cognitive load theory is real and measurable. There's a consistent pattern: people can absorb 3-5 new concepts per session effectively. More causes confusion. Less causes boredom.

Template based code generation is incredibly powerful for creating consistent, modifiable systems. Our entire workspace setup is template driven, making customization trivial.

What's next for GraphMyMind

Collaborative knowledge graphs. Imagine a classroom where the teacher can see aggregate knowledge gaps - not just who's struggling, but exactly which concepts are causing confusion across the class.

Integration with more learning sources. PDFs, videos, interactive exercises. Each source updates your knowledge graph differently.

Community knowledge sharing. What if you could download knowledge graphs from experts in a field? Start with their understanding as a template, then make it your own.

The goal is to make learning visible, measurable, and optimizable. No more guessing what you actually know. No more redundant studying. Just clear paths from ignorance to understanding.