There is a familiar moment for anyone who has spent enough time with Obsidian, Roam Research, or another personal knowledge management system.
You open the graph view.
Hundreds of notes bloom across the screen. Lines connect books to ideas, ideas to projects, projects to people. Clusters emerge like constellations. You zoom out and look at the accumulated structure of months — or years — of thinking.
It is beautiful.
And then you try to use it.
That is where the illusion begins to break.
The Knowledge Graph Has a Scaling Problem
Graph views are one of the most compelling ideas in modern knowledge management.
They also expose a fundamental confusion between visualizing knowledge and working with knowledge.
With twenty nodes, a graph is intuitive.
With fifty, it becomes interesting.
With five hundred, it often becomes a cloud of labels and edges.
With thousands, the graph can become what I privately started thinking of as beautiful garbage: visually impressive evidence that information is connected, but increasingly poor at telling me which connections actually matter.
This is not primarily a rendering problem.
It is an information architecture problem.
A conventional graph treats every explicit relationship as something worth displaying. But human attention does not work that way. The fact that two notes are connected does not mean I need to see that connection right now.
As a graph grows, the number of potentially visible relationships grows with it. More information produces more edges; more edges produce more visual competition; and eventually the representation intended to clarify structure begins obscuring it.
The graph succeeds as a map of what exists.
It fails as an interface for deciding where to think next.
That distinction became increasingly important to me.
I did not want another prettier map of my notes.
I wanted a system that could participate in thought.
Search Solves Retrieval. It Does Not Solve Serendipity.
AI has made one part of knowledge management dramatically easier: retrieval.
If I know what I am looking for, modern semantic search and retrieval-augmented generation can usually help me find it.
Ask a question. Retrieve relevant documents. Feed them into a model. Generate an answer.
This is useful.
But it assumes something surprisingly restrictive:
I already know what question to ask.
Some of the most valuable connections in creative and intellectual work do not begin with a query.
They begin with something more like:
Wait. These two things might be related.
A concept from a paper suddenly explains a problem in a project.
A note written six months ago becomes relevant to something I am writing today.
Two clusters that were created for completely different purposes turn out to share an underlying structure.
You did not search for the connection because you did not know the connection existed.
This is serendipity.
And it is one of the places where I think many AI knowledge tools still misunderstand what an intelligent interface should do.
The obvious application of AI to a personal knowledge base is:
User asks → AI retrieves → AI answers.
The more interesting application is:
User thinks → system observes structure → potentially valuable connection emerges → user decides whether to follow it.
That difference became the foundation of Infinite Graph.
I Wanted AI to Suggest, Not Decide
There is an uncomfortable extreme at both ends of AI knowledge management.
At one end, AI does almost nothing until explicitly summoned. It behaves like search with a conversational interface.
At the other, the AI aggressively summarizes, categorizes, reorganizes, and rewrites everything until the user’s knowledge base starts reflecting the model’s ontology instead of the user’s own.
Neither was what I wanted.
My design principle became simple:
AI assists. The user decides.
The system should be capable of discovering latent relationships without silently converting those relationships into facts.
That means separating several operations that are often collapsed into one.
A system can detect a possible relationship.
It can rank that relationship.
It can explain why the relationship may matter.
But actually incorporating that relationship into the user’s graph should remain a separate decision.
This distinction sounds minor. Architecturally, it changes almost everything.
AI suggestions become proposals rather than mutations.
Semantic similarity becomes evidence rather than truth.
The knowledge graph remains the user’s model of the world instead of gradually becoming the model’s model of the user’s world.
That is the kind of AI second brain I wanted.
So I started building it.
From Graph Visualization to Graph Interface
Infinite Graph began from a fairly simple dissatisfaction:
What if the graph itself were the primary workspace rather than a decorative visualization attached to a note-taking application?
That question forced me to reconsider the graph at several levels.
A large graph cannot simply render every piece of information at equal importance. It needs hierarchy.
It needs clustering.
It needs semantic zoom.
It needs spatial organization that remains comprehensible as the graph grows.
And, increasingly, it needs an intelligence layer capable of asking:
Which part of this graph might matter to the user right now?
That produces a very different design target from the traditional “network of notes.”
The interface has to mediate between at least three structures:
- what the user explicitly created,
- what the system can infer,
- what deserves the user’s attention now.
The third problem is the hardest.
Because relevance is contextual.
Two nodes may be semantically similar but useless together. Two apparently distant nodes may share a structural analogy that produces an unusually valuable idea.
So simply drawing more AI-generated edges would reproduce the original problem at a larger scale.
The solution to graph overload cannot be more graph.
Not Every Possible Connection Deserves an Edge
This became one of the most important constraints in the design.
A knowledge system capable of generating connections autonomously needs to be more selective than a human manually linking notes — not less.
Otherwise AI turns graph entropy into an industrial process.
So I began treating connection discovery as a retrieval and ranking problem rather than an edge-generation problem.
The system can explore nearby context, semantic neighborhoods, clusters, and structural relationships without exposing all of that machinery to the user.
Most candidate relationships should die quietly.
Only a small fraction should become visible suggestions.
This produces a useful asymmetry:
The machine can search broadly. Human attention should remain narrow.
That principle also affects the visual design.
Infinite Graph is deliberately information-first. The interface should not demand attention merely because something can be animated, colored, or rendered.
Complexity should exist underneath the interface when necessary, not be celebrated on top of it.
A sophisticated knowledge system should often look simpler as its internal machinery becomes more capable.
The Graph Should Change With Distance
Another problem with large knowledge graphs is that they often treat zoom as geometry.
Zoom out: things become smaller.
Zoom in: things become larger.
But zoom in a knowledge interface should represent a change in abstraction, not merely scale.
From far away, I do not need individual note titles. I need territories.
Closer, I need clusters and relationships.
Closer still, individual concepts become meaningful.
At the lowest level, I want the actual content and its local context.
In other words, the graph should behave less like a poster that I magnify and more like a map.
Maps have understood this problem for decades. A world map does not attempt to display every residential street simultaneously. Information appears and disappears according to scale because relevance depends on observational distance.
Knowledge interfaces need the same principle.
Semantic zoom, hierarchical clustering, and level-of-detail rendering therefore became architectural concerns rather than cosmetic features.
The objective is not to make a giant graph technically renderable.
The objective is to make it cognitively navigable.
Those are different engineering problems.
AI Should Work in the Background of Thought
This eventually led to the idea I care about most in Infinite Graph: autonomous connection discovery.
I do not want to continuously stop what I am doing and ask an AI:
Can you find something interesting about this?
That interruption itself is a failure of interface design.
If the system already has access to the structure of my knowledge, it should be able to perform bounded exploration in the background.
It can detect unusual overlaps.
It can notice when previously distant regions of the graph become relevant to each other.
It can surface a dormant note when new information changes its significance.
It can propose a connection and explain the evidence behind it.
Then it gets out of the way.
The result I am aiming for is not an omniscient AI assistant.
It is something closer to computational serendipity.
A mechanism for increasing the probability that useful ideas collide.
That is a much narrower objective than “AI that thinks for you.”
I also think it is considerably more useful.
Why I Built Infinite Graph
I did not build Infinite Graph because I thought the world needed another note-taking app.
There are already excellent tools for writing Markdown files, storing documents, building wikis, and searching personal archives.
I built it because I kept encountering a different problem.
I could store knowledge.
I could retrieve knowledge.
I could visualize knowledge.
But I still had to manually discover most of the interesting relationships inside it.
The graph showed me what I had connected before.
I wanted a system capable of helping me discover what I might connect next.
That required treating the knowledge graph not as the final visualization of thought, but as an active computational substrate beneath it.
Search becomes retrieval.
Clustering becomes abstraction.
Graph traversal becomes contextual exploration.
AI becomes a mechanism for generating and ranking hypotheses about relationships.
And the interface becomes the boundary where those machine-generated possibilities meet human judgment.
That boundary is where I think the interesting work in AI knowledge management is going to happen.
Beyond the “Second Brain”
For years, personal knowledge management has been dominated by the metaphor of the second brain.
It is a useful metaphor, but perhaps the wrong ambition.
Most digital second brains are extraordinarily good memories.
They store.
They index.
They retrieve.
They remind.
But memory is only one component of cognition.
A more interesting system would also help with association: bringing previously separate representations into contact at the moment when that contact becomes useful.
Not by generating endless “insights.”
Not by replacing judgment.
And certainly not by covering the screen in automatically generated edges.
The goal is much simpler:
Make valuable connections easier to encounter.
That is the problem I am trying to solve with Infinite Graph.
The project is still evolving, and many of the difficult questions are unresolved: how aggressively should the system explore? How should relevance decay over time? How do you distinguish genuine structural novelty from superficial semantic similarity? How much machine reasoning should remain invisible?
But I am increasingly convinced of one thing.
The future of knowledge tools is not a larger graph.
It is not a prettier graph either.
It is a graph that understands when not to show you the graph — and when one unexpected connection is worth interrupting you for.
That is the interface I wanted.
So I built it.