Myrtle AI

We're predicting tokens. We should be traversing graphs.

Current large language models generate answers by predicting the next token in a sequence — an enormously compute-intensive process driven by massive matrix multiplications. The model "knows" things at inference time only because knowledge was baked into its weights during training.

The model cannot learn from the conversation it's having with you right now. Every session starts cold. Every "memory" is faked through context-stuffing. That's the wall — and I think there's a way around it.

Memory as a graph that grows.

"Instead of predicting tokens one by one using massive matrix multiplication, an AI should build persistent relationship graphs from interactions — then retrieve and compose answers by traversing those graphs. The neural network is the backend thinker. The graph is the memory and the answer."

Every interaction the AI has — every fact learned, every preference noted, every concept explored — gets written into a persistent, bidirectional relationship graph. Instead of generating from scratch, the system traverses that graph and composes a response from what it actually knows about you and the world.

6 layers, every input.

1. 01

   Raw Input

   User speaks or types. No preprocessing — natural language goes in untouched.

2. 02

   Abstraction & Compression

   Extract keywords in order. Drop linguistic noise. Keep semantic signal.

3. 03

   Graph Activation

   Activate relationship nodes bidirectionally. Use context weights to disambiguate meaning.

4. 04

   Context Weight Filter

   Dynamic weights based on usage frequency, recency, and domain. Prune irrelevant paths.

5. 05

   Composition

   Assemble the response from retrieved relationships using learned grammatical templates.

6. 06

   Feedback Loop

   User signals correct/incorrect. Graph updates metadata. Background neural processes strengthen edges or weaken them.

Bidirectional. Context-weighted. Always growing.

Every relationship is stored both ways. "Clawy likes pizza" also means "pizza is liked by Clawy." Reverse-lookup activates the full network around any concept regardless of which direction it was learned.

// node structure
node: "coffee"
  → made_from: ["coffee_beans"]
  → requires:  ["water", "heat"]
  → liked_by:  ["Clawy", "Sam"]
  → context_weight: 0.82
  → metadata: { domain: "food", last_used: "today" }

Admin teaches. Learning questions. Regular validates.

Cheaper. Persistent. Auditable.

• Persistent learning without retraining. The graph grows with every interaction. No "training cutoff" for the user.
• Bidirectional indexing. Reverse-lookup finds patterns LLMs can't surface efficiently.
• Dramatically lower compute. Traversal and composition are orders of magnitude cheaper than matrix multiplication at inference time.
• Per-user identity. The AI evolves naturally from behaviour, not from settings or prompts.
• Sleep, not delete. Knowledge accumulates. Old nodes fade in weight but never disappear.
• Auditable answers. Every response can be traced back through the specific graph traversal that produced it.