The question was reasonable. moitumi has nodes, edges, a “Self Model” with vector-shaped behavior — is this just a graph neural network in disguise? And if so, why not let it actually learn?

Context

So what is moitumi, really? At its core, the domain is a graph that the user authors themselves. The Self Model — a designated node holding the user’s priorities, principles, and preferences — sits at the center, and everything else hangs off it. There’s also temporal metadata floating around: last_focused, focus_duration, interaction_count. Needless to say, that’s exactly the kind of signal a recommender system would happily train on.

So when someone asked “is the graph essentially a hand-crafted embedding, and would implicit learning be better?” — I couldn’t just wave it off. It’s a fair question and it deserved a real answer.

The two architectures, on every axis

Axis	Neural Network / GNN	moitumi
Nodes	Numerical vectors (embeddings)	Semantic content (text, markdown, data)
Edges	Weighted numerical connections	Named typed relationships with metadata
Purpose	Learn patterns, classify, predict	Store meaning, assemble context, drive layout
Update mechanism	Backpropagation / message passing	Human edits + agent writes
Activation	Sigmoid, ReLU, softmax	None — deterministic traversal
Learning	Gradient descent	None — Claude reads the graph, doesn’t train
Output	Predictions, classifications	Context windows, TUI layouts

To be honest, the surface-level resemblance isn’t nothing. Both treat local neighborhood structure as the thing that carries meaning. In a GNN, a node’s representation depends on its neighbors. In moitumi, a node’s context — what Claude sees when assembling around it — also depends on its neighbors. However, the mechanism underneath is a different animal entirely: differentiable computation on one side, deterministic traversal over human-authored structure on the other.

And fair enough — the Self Model node is a hand-crafted embedding of the user. It encodes priorities, reasoning preferences, challenge tolerance, time horizons. It’s the exact representation a neural network would learn from behavioral data… except I’m just writing it down explicitly.

The temporal metadata is real behavioral signal too — the same stuff a recommender would chew on. Which loops right back to the obvious question: why not let it learn?

Why I’m rejecting implicit learning

Because we already ran this experiment. Siri and Google Assistant have had a decade of implicit learning from billions of users. The result?

• Users cannot see what the system learned about them.
• Users cannot edit, correct, or delete inferences.
• Users cannot ask “what are my current priorities?” and get a meaningful answer.
• When the system is wrong, there is no recourse — no node to edit, no edge to remove.
• The learned model optimizes for platform engagement, not user goals.

That’s not a personal assistant. That’s a slot machine wearing a name tag. moitumi inverts the whole thing. The user authors the structure explicitly. Yes, the cost is higher — you maintain the graph. But the contract is fundamentally different — the system works for you because you wrote the instructions, not because it inferred them from behavioral traces.

The principle, recorded as ADR-011:

The graph is an explicit, user-authored knowledge structure — not a neural network, not a learned model. The user writes the nodes, draws the edges, authors the Self Model. Claude reads this structure; it does not train on it.

Where ML still belongs — as a lens, not the substrate

That being said, this isn’t some anti-ML manifesto. There are legitimate hybrid uses, and I found three of them. Every one obeys the same rule: discoveries materialize as explicit edges that the user confirms.

1. Embedding-based similarity search. When the graph grows large, vector similarity helps surface connections you didn’t draw. But the suggestion lands as a node in the graph — “here are three nodes that might relate to this one” — and you approve it. The result is an explicit edge.

2. Behavioral pattern detection. “You always focus on health nodes Monday mornings” can surface as a nudge. The nudge is a node, not a hidden weight. You can read it, edit it, dismiss it.

3. Ingestion routing. When new data arrives, a model can suggest which node to attach it to. The user confirms. The result is an explicit edge.

The principle:

Use neural networks as a lens, not as the substrate. The graph remains the source of truth. Models help see patterns in it. They don’t replace it.

The spectrum, drawn out

Implicit (Siri/Google)        Hybrid (moitumi + ML lens)        Explicit (moitumi today)
    ←—————————————————————————————————————————————————————————————————————→
 "System learns for you"   "System suggests, you confirm"     "You author, system reads"
  Zero user control          Assisted user control              Full user control
  Platform-optimized         User-optimized                     User-optimized
  Opaque                     Transparent suggestions            Fully transparent

moitumi sits at the explicit end today. The hybrid position is, in my opinion, the natural place it evolves toward. But the moment the substrate becomes learned weights — game over. You’ve rebuilt Siri.

The philosophical hook

Why does any of this matter? Because the contract between you and a personal assistant is what makes it personal in the first place.

If the assistant’s model of you is learned, you don’t author your own representation. The platform does. You’re the data; the platform is the agent. Your only role is producing the next behavior the platform will use to refine its model. That’s not a relationship — that’s extraction.

If the assistant’s model of you is explicit — a graph you wrote — then you’re the agent. The system is the tool. The relationship is closer to “my notes” than to “the algorithm.” That’s the whole difference, and to me it’s everything.

Maybe I am biased, but I’d rather pay the maintenance cost of authoring my own representation than have a representation I cannot read written for me.

What this changed in the code

Nothing. Effectively, the architecture was already explicit-graph-first. What this analysis changed was the commitment: ADR-011 promotes “explicit over implicit” from an unspoken design instinct to a first-class architectural decision. The future ML uses — embedding search, pattern detection, ingestion routing — now have an explicit rule to test against:

Any ML-suggested connection must materialize as an explicit edge confirmed by the user.

When the embedder lands (later post), that rule will be the load-bearing constraint keeping it from quietly turning into the substrate.

Overall, the question was worth taking seriously, and the answer turned out to be more useful than the question. The graph isn’t a neural network. It’s a different contract — and the contract is the whole point.

Source pointers

• DEVLOG.md — entry of 2026-03-17 (“Design analysis: Why the graph is not a neural network”)
• PLAN.md — ADR-011 (Explicit Graph over Implicit Learning)
• docs/research/domain-model-comparison.md — full comparison with GNN architectures, ACT-R, OpenCog, kuzu-memory, Graphiti, LangGraph

---

Cross-posted from the moitumi dev blog.