Infinite Graph — Human-Led AI

A visual thinking workspace where AI expands your ideas without taking over—suggesting possible connections while you decide what belongs.

Comment

Inspiration

Some ideas disappear before we know they are important.

A thought may pass only once through a person’s mind and still alter the direction of their work years later. A strange connection may initially look irrelevant, irrational, or impossible to explain, yet eventually become the foundation of a story, a research question, or an entirely new career.

The problem is that importance is usually recognized retrospectively.

Most tools preserve completed outputs: documents, notes, summaries, and polished conclusions. They are good at storing what a person has already decided. They preserve much less of the uncertain process that came before—the abandoned paths, provisional associations, revisions, and connections whose meaning has not yet become clear.

AI systems introduce another tension. They can generate articulate answers almost immediately, but an answer produced too quickly can conceal the possibilities the user never had the chance to examine. The issue is not that AI generates ideas. The issue is whether generated material is silently treated as the user’s settled thought.

Infinite Graph began with a different premise:

AI can suggest a path. It cannot decide why that path matters to someone.

Meaning cannot be assigned from outside with certainty. The same profession, memory, concept, or relationship may carry radically different significance for different people. Even another human being cannot authoritatively determine what a thought means within someone else’s life.

Infinite Graph is designed to preserve not only ideas, but the human choices and unresolved connections through which meaning may eventually emerge.

An unexplained connection is not necessarily an error.

It may be an unresolved trace.

What it does

Infinite Graph is an AI cognitive workspace for visually developing ideas without surrendering authorship.

A user begins with one thought and expands it across an open graph canvas. Ideas are represented as nodes. Users can connect them, edit them, group related concepts, reorganize structures, and return to earlier branches.

When a user selects a node, the AI proposes several possible directions as temporary ghost nodes.

These suggestions are not automatically added to the graph.

The user can:

  • accept a suggestion;
  • edit it before accepting it;
  • leave it unselected;
  • dismiss the remaining suggestions;
  • create a completely different node;
  • make a connection the system does not understand.

Only explicitly accepted content becomes part of the persistent graph.

The product therefore changes the role of AI from answer generator to possibility generator. AI performs part of the divergent work by presenting several directions. The user retains the convergent work: deciding what is relevant, what should be changed, and what belongs in the graph.

The current prototype includes:

  • an open node-and-edge canvas;
  • node creation and keyboard editing;
  • multiple selection and grouping;
  • AI-generated branching suggestions;
  • temporary ghost nodes requiring explicit acceptance;
  • provenance for manually created and AI-assisted content;
  • preservation of suggestion slates and candidate outcomes;
  • undo and redo;
  • local persistence with IndexedDB;
  • JSON import and export;
  • onboarding presets for several starting states.

The immediate product value is practical:

  • users do not have to face a completely blank page;
  • possible directions remain visible outside working memory;
  • earlier thought structures can be revisited;
  • only chosen ideas become part of the user’s work.

Its deeper purpose is to reduce the number of meaningful traces that disappear before the user can recognize them.

How we built it

Infinite Graph was built as a local-first web application using React, TypeScript, Vite, and React Flow.

Local-first graph persistence

The user’s persistent graph is stored in the browser through IndexedDB. The entire graph does not need to be uploaded merely to survive between sessions.

Users can also export and import the graph as JSON.

When AI suggestions are requested, only the context needed for that request is sent through the application’s AI request pipeline. The persistent graph remains locally stored unless a specific feature requires selected context to be transmitted.

Ghost nodes as an approval boundary

AI responses are transformed into temporary ghost nodes rather than inserted directly into the graph.

This creates a clear data boundary:

AI suggestion
→ temporary candidate
→ human review
→ optional edit
→ explicit acceptance
→ persistent graph node

The visual distinction reflects a structural distinction. Before acceptance, an AI candidate is not treated as part of the user’s graph.

Provenance

Infinite Graph distinguishes among:

  • content created manually;
  • AI suggestions accepted without editing;
  • AI suggestions edited before acceptance.

This makes authorship and transformation inspectable at the data level.

The system also preserves the set of candidates presented during a suggestion session and records whether candidates were accepted, edited before acceptance, or left unselected.

A final graph snapshot cannot reveal this process on its own. It shows what remained, but not the alternatives the user considered.

Centralized graph operations

Graph changes pass through a centralized operation pipeline rather than being implemented as unrelated mutations throughout the interface.

This architecture supports:

  • predictable undo and redo;
  • consistent persistence;
  • testable graph mutations;
  • clearer separation between interface events and graph state.

It also provides the foundation for a future append-only history of graph decisions. The current prototype preserves the resulting graph and AI suggestion events; a complete chronological history of every graph edit is the next architectural layer rather than a feature we claim to have completed already.

A broader cognitive architecture

The prototype focuses on the core human–AI interaction loop, but it was designed as the visible layer of a broader system.

The long-term architecture separates:

  1. shared concept and relationship types;
  2. general concept profiles;
  3. personal concept profiles;
  4. the explicit user graph;
  5. personal meanings attached to connections;
  6. the topology of the graph as a whole;
  7. behavioral and decision history;
  8. recommendation and inference systems.

We intentionally did not attempt to implement every layer during the hackathon.

The prototype tests the foundational rule on which the later architecture depends:

AI proposes possibilities. Meaning enters the graph through human choice.

Challenges we ran into

Preserving agency without making AI decorative

The main product challenge was deciding what AI should be allowed to do.

Allowing the model to generate and insert content automatically would have been easier. It also would have made the graph an unclear mixture of human thought and machine completion.

We wanted the AI to be useful without making its output authoritative.

Ghost nodes became the solution. The AI can widen the field of possibilities, but cannot decide which possibility becomes part of the user’s cognitive structure.

Human control is therefore not expressed only through copy or policy. It is implemented through persistent and provisional data states.

Generating concepts rather than grammatical phrases

An early recommendation system produced outputs that were linguistically valid but cognitively weak.

For a node such as “greeting,” it generated phrases resembling:

  • form of greeting;
  • emotion of greeting;
  • transition of greeting.

The desired results were concepts such as:

  • meeting;
  • etiquette;
  • language;
  • society.

This exposed the real nature of the problem.

We were not building ordinary text completion. We were building concept exploration.

Useful candidates must vary across relationship types while avoiding paraphrase, shallow derivation, and repetition. They may be semantically near, structurally analogous, socially related, emotionally associated, or deliberately distant.

The current prototype addresses this through prompt constraints and output filtering. A mature version will require a multi-stage recommendation pipeline rather than relying on one model response as the final answer.

Separating final state from decision history

Saving the current graph is not the same as preserving how it formed.

A final state cannot tell us:

  • what alternatives were presented;
  • whether accepted content was edited first;
  • what was left unselected;
  • whether a node was later removed;
  • whether a previously ignored concept reappeared independently.

This led us to treat provenance and suggestion events as first-class product data.

It also revealed a remaining architectural gap: ordinary graph edits still need their own append-only event history if the system is to preserve cognition as a temporal process rather than only a persistent structure.

Browser interaction reliability

Many difficult problems were not conceptual. They involved ordinary editing behavior in a real browser:

  • keyboard focus;
  • F2 editing;
  • Delete and Backspace handling;
  • placeholder nodes;
  • multi-selection;
  • ghost-node cleanup;
  • text overflow;
  • undo behavior;
  • rendering and visibility timing.

Some failures passed static checks and component tests but still occurred during actual browser interaction.

For example, an editor could attempt to focus before its React Flow wrapper had become visible. The call technically ran, but the browser silently left focus on the document body.

This taught us to distinguish code-level correctness from interaction-level correctness. For a cognitive tool, small input failures are not cosmetic. They interrupt the thought itself.

Preserving unexplained connections

A user may connect two concepts that appear unrelated.

The reason may be:

  • a private memory;
  • visual similarity;
  • metaphor;
  • sound association;
  • an unfinished fictional idea;
  • a momentary intuition;
  • something the user cannot yet articulate.

Automatically interpreting or correcting that connection would replace uncertainty with the model’s preferred explanation.

Our design principle became:

Preserve first. Interpret only when requested. Treat every interpretation as provisional.

The user’s connection is part of the explicit graph immediately. A future AI explanation, if requested, must remain separate from the user’s own recorded reason.

Accomplishments that we're proud of

We are proud that Infinite Graph implements human agency as a system property.

The product does not merely display a message saying that the user is in control. It enforces control through:

  • provisional AI states;
  • explicit approval gates;
  • distinguishable provenance;
  • reversible operations;
  • local graph persistence;
  • separation between human records and AI inference.

We are also proud that the product does not require the user to perform a separate labeling task in order to create useful learning signals.

A single decision can simultaneously:

  • advance the user’s work;
  • expand the graph;
  • clarify a preference;
  • produce evidence for improving later suggestions.

The user is not annotating arbitrary data for the system. They are deciding what belongs in their own work.

Another accomplishment was choosing restraint.

Infinite Graph does not automatically explain every connection, assign psychological meaning to the user’s graph, or reorganize the user’s thinking into a supposedly superior structure.

The system can suggest. It can preserve. It can eventually help reconstruct context.

It should not claim ownership over meaning.

What we learned

We learned that AI-generated ideas may not be the most valuable data produced during an AI-assisted thinking session.

The more valuable element may be the situated human decision made among those ideas.

Generated candidates are inexpensive and reproducible. A meaningful choice made inside a real project reflects context, authorship, and personal stakes.

We also learned that completed outputs are compressed representations of cognition.

A document preserves conclusions. It rarely preserves:

  • abandoned routes;
  • temporary associations;
  • competing possibilities;
  • moments of uncertainty;
  • revisions that changed the direction of the work.

Attempting to reconstruct the original thinking process from the final document is inherently lossy.

A graph can preserve more, but only when it records choices and change over time rather than functioning as a static diagram.

We learned that personalization has its own failure mode.

A system trained only to maximize acceptance will eventually offer increasingly predictable suggestions. It may become more accurate at reproducing the user’s existing habits while becoming less useful for discovery.

A cognitive workspace must balance:

  • familiarity and novelty;
  • likely acceptance and meaningful surprise;
  • personal patterns and unexplored directions.

The objective cannot be acceptance rate alone.

Finally, we learned that human sovereignty in AI systems has to be implemented below the level of language.

It depends on:

  • which data is provisional;
  • which actions require approval;
  • whether origin is preserved;
  • whether edits are reversible;
  • whether inference is separated from fact;
  • whether the system can tolerate uncertainty without erasing it.

What's next for Infinite Graph — AI Cognitive Workspace

1. Append-only graph history

The next engineering step is to extend event persistence beyond AI suggestion sessions.

We plan to record graph operations such as:

  • node creation;
  • node editing;
  • node deletion;
  • edge creation and deletion;
  • grouping and ungrouping;
  • undo and redo;
  • later revisits and reuse.

This will allow Infinite Graph to preserve the graph as a temporal process rather than only its latest state.

The objective is not surveillance or productivity scoring. It is to retain enough context that the user can later understand how a structure formed.

2. A multi-stage recommendation pipeline

The current prototype uses constrained model generation.

The next recommendation engine will separate the task into stages:

  1. generate a broad candidate pool;
  2. classify candidate relationship types;
  3. remove paraphrases and shallow grammatical derivatives;
  4. compare candidates with the existing graph;
  5. detect duplication;
  6. balance nearby and distant connections;
  7. rank a diverse final slate.

This system will optimize not merely for what the user is likely to accept, but for what may create a useful and non-obvious direction.

3. Personal ranking without cognitive confinement

As interaction history accumulates, Infinite Graph can learn which types of suggestions tend to be useful to a particular user.

The central learning target is not:

What words should the model generate?

It is:

Which possible connection should this user see at this moment?

Personalization will need explicit exploration controls so that the system does not trap users inside their previous patterns.

A mature ranking objective should combine acceptance with what we think of as validated surprise: a suggestion that is meaningfully different from the existing graph but still judged useful by the user.

4. Historical context and cognitive archaeology

A person may return years later to a connection and no longer remember why it was made.

Infinite Graph could preserve the context surrounding the original event:

  • nearby nodes;
  • recently edited concepts;
  • active branches;
  • the path taken during the session;
  • whether the connection came from an AI suggestion;
  • the state of the graph at that time.

The system could later offer several possible reconstructions.

These would be presented as hypotheses, not facts.

The purpose would not be to tell the user what they meant. It would be to return enough evidence for the user to recognize—or reject—the possible explanation.

5. A user-owned context layer for personal AI

Most current AI memory systems extract facts or preferences from conversation.

Infinite Graph aims to preserve a different form of context:

  • explicitly approved relationships;
  • evolving concept structures;
  • human decision traces;
  • unresolved connections;
  • the topology of how a person moved through ideas over time.

This context could eventually be made available to personal AI systems under user-controlled permissions.

The long-term vision is not an AI that authoritatively models a person from the outside.

It is an environment in which the person deliberately builds, owns, revises, and grants access to their own cognitive structure.

Infinite Graph is not designed to decide what a person’s work or life means.

It is designed so that fewer potentially meaningful traces disappear before the person has the chance to decide for themselves.

Built With

Share this project:

Updates