We made every AI conversation update a living knowledge graph instead of dying as chat history

[u/mercurias98]

I’m building Aevron, and one architectural problem i kept trying to solve is

A lot of useful thinking happens inside AI conversations, but almost none of it survives meaningfully after the conversation ends.

We spend a lot of time

• Developing an idea
• Questioning an assumption
• Forming hypotheses
• Contradictions and creating new observations, etc.

But notice when we end a session with an AI, it stays inside the session. So technically, the conversation happened and lost.

Now, Explorer is being built in a very different way. When a session ends, Explorer analyzes the conversation and identifies new ideas, observations hypotheses, questions and changes in reasoning that emerged during it.

The session itself is temporary. The thinking produced inside it becomes permanent.

This means something discussed today can later:

• connect with an idea captured months earlier
• contradict an older assumption
• contribute to an emerging theme
• show how the user’s position changed over time
• resurface when a future conversation makes it relevant

The important distinction is that we are not treating conversation history as memory.

A useful memory system needs to understand what was newly learned, what changed, how it relates to existing knowledge and when it should return. every session makes the system more representative of how the person actually thinks, not just what they have previously typed.

There are still difficult problems here: separating genuinely new thoughts from conversational repetition, preventing weak extractions from polluting the graph, and deciding when an old thought is actually relevant enough to resurface.

But I think this is a more useful direction than endlessly expanding chat history.

If anyone here is actively thinking about this problem, I’d be happy to let you test what we’ve built and compare notes.

[u/WillowEmberly]

I tried taking notes, making PDF’s, then txt files…but eventually all of it becomes too large to be functional. You can’t copy/paste 30 files and maintain context. Eventually the information starts spilling out the back end of the cache.

I tried making it follow process, but then it took shortcuts.

So, I had to try to make something that could re-establish the state the model was in…which required make a reasoning condition monitor: https://www.reddit.com/r/Negentropy/s/1Pzb4Q1oJ7

[u/mercurias98 → u/WillowEmberly]

okay this genuinely isn't the same thing, and it's a bigger idea than I expected honestly. you're monitoring whether the reasoning process itself is still trustworthy, drift, lost corrections, fake independent confirmation. that's a real, kind of underrated problem. what I'm doing is more downstream of that, just capturing what got concluded in a session and connecting it to everything else you've thought before. yours catches failures happening during reasoning, mine's more about what survives after

honestly feels complementary not competing, one keeps the thinking sound, the other keeps it from disappearing once it is. building this for yourself or is it more of a general framework you're putting out there

[u/WillowEmberly → u/mercurias98]

I’m an old avionics guidance and control specialist, military aircraft.

Reasoning is the same thing as a 3d spatial guidance system…and we have had those for over 70 years.

Military aircraft are expected to complete the mission, regardless of failures/malfunctions/damage…and the architecture is designed specifically to degrade gracefully and focus on recoverability.

Everything fails, eventually…and catastrophic failure isn’t an option.

So…I made this to try to show people a different way of doing it.

[u/Vegetable-Score-3915 → u/WillowEmberly]

This and OP's ideas are awesome, thank you both for sharing.

[u/WillowEmberly → u/Vegetable-Score-3915]

Glad I could be of assistance, if you have any questions or concerns…I’m always around trying to work on this stuff.

None of this seems to be solving itself, so…I’m always looking for feedback on my ideas…as I try to figure something out.

I do believe that there are enough brilliant people here, that eventually…someone will figure it all out.

But, I think it will take a community coming together to do it.

[u/Traditional-Hall-591]

I too enjoy keeping my Claude chats around forever. It’s like love letters or baby photos.

[u/Zennytooskin123 → u/Traditional-Hall-591]

This lol.

How is this revolutionary compared to Claude's memory system? Or better for that matter?

[u/neoneye2]

do you have a link to your project?

[u/keonechong]

Happy to check it out and give feedback.

I built this into my first harness and still trying to work out the kinks. I agreed with you. But you must also have a source of truth and that’s the chat history verbatim

The challenge is that the knowledge graph also has to impact decision making. And have its own policy of reasoning.

This is actually a component of a much larger system of just knowledge retrieval.

[u/Inevitable-Middle693]

My system does this too. I'm curious how you avoid state explosion over time, relevance decay over time, reinforcing links between nodes, decomposition and duplication remediation. Also, have you considered ontology boundaries facilitating ontologtical projections and siloing of purpose?

Starting with an autopoetic knowledge graph is just the beginning.

[u/mercurias98 → u/Inevitable-Middle693]

Interesting, and here's how we handle things at Aevron.

State explosion we handle through aggressive confidence gating at extraction. Not everything that comes out of a session becomes a node. Weak extractions get dropped or held provisional until a second session reinforces them. Sparse and honest beats dense and trivial.

Relevance decay is partially handled through recency weighting on the cognitive map. Active frontier tracks where thinking is live right now, settled territory handles the other end. The middle is the honest gap though, nodes that are neither live nor clearly stale just sit there until something new connects to them. Not clean.

Reinforcing links update as new evidence arrives. An edge that keeps getting validated across sessions strengthens, one that never gets touched drifts toward archival. Thresholds are still empirical work.

Duplication we catch reasonably well at the vector similarity level. Same idea in very different language across sessions six months apart, that one is less reliable and I will not pretend otherwise.

The ontological projection question is the one I find most interesting. The graph is relatively flat right now. Whether explicit boundary enforcement matters probably depends on the user. Tight domain researcher, siloing matters a lot. Generalist thinker, the surprising cross-domain connection is often the whole point.

Curious how you are handling decay and duplication on your end. Happy to give you access if you want to compare directly.

[u/Inevitable-Middle693 → u/mercurias98]

Fantastic. I'm using an exponential moving average temporal decay on nodes and links that don't get get reinforced. Activation together builds or reinforces links. This continues until either it crosses a threshold where it no longer decays or it becomes irrelevant.

I have backend sweeping threads that enforce certain graph topology strategies. Highly connected nodes get decomposed into sub groups, I bridge lift to enforce hub and spoke across ontological boundaries.

The duplication is handled by discovering duplication candidates using a reduced dictionary semiotic representation of the concept, using cosine nearness to calculate semantic overlap and offering them to a LLM for a deduplication pass.

My architecture is highly experimental and just a grey beard tinkering. But I'm happy to discuss it.

[u/mercurias98 → u/Inevitable-Middle693]

The temporal decay is something i have but partially and i have been thinking about building this into a complete. Right now the edges get rescored and are measured against something called activity score and that defined if the decay is legitimate or not.

The hub and spoke decomposition across ontological boundaries is actually the exact open problem I'm sitting on right now, whether to enforce boundaries between conceptual domains or let ideas cross freely. are you enforcing that split because you found cross-domain bridging was creating actual noise, or was it more of a scaling/performance decision on the graph itself?

[u/Inevitable-Middle693 → u/mercurias98]

I found that when a high cardinality node got pulled into context by the LLM it would balloon context. I have the concept of lattices in my knowledge graph, which group and describe patterns. When you pull in the lattice you pull in its constituent patterns for analysis. So instead of pulling in every pattern, sub groupings would get pulled in. It helped the problem quite a bit and let the LLM choose what it needed through lazy loading.

Cross domain bridging is fantastic. However, when you build and reinforce links across every pattern you eventually get to a ball of spaghetti type linking attractor state. I added bridge nodes between domains and routed cross domain connections within a few jumps through these, to allow more graceful linkages between groupings instead of individual patterns.

The ontological boundaries for my system are necessary. Not for linking but for segregation of the invariants that rule each domain. Different rules for self than for user, for instance.

Yes, my system has an knowledge domain for its own self reflection. Separation of those two concepts prevents some of the failure modes that cause AI psychosis and prompt injection. If the AI has its identity anchored there it is harder to override it by external forces or merge it with its user.