INTENT — the spec, verbatim, immutable

This file is Kieran's original specification, unedited. It is not a summary and must never become one. Every rotation grounds here.

It exists because of a failure mode observed 2026-08-07: coined vocabulary becomes a channel, and the channel gets skimmed. experience-sourced, rotation-sourced, invariance/inversion, attachment survival — each was a useful coinage, and collectively they redirected the work away from the intent into navigating themselves. The system's own alluvial claim, operating on the people building it.

Measured drift at the moment this file was written: 2 preference pairs accumulated against a spec calling for hundreds or thousands; 24 nodes in the field; 16 validation traces against 7 real field turns. The scaffolding was built and then studied instead of run.

---

Don't fine-tune the conclusions. Build a system that maintains the live weighting field outside the model and uses the LLM as the rotator.

The architecture I'd try is:

LLM + persistent graph + live weights + recursive perturbation loop

The LLM proposes/rotates shapes. The external system remembers what the LLM itself cannot.

Concretely, every meaningful turn becomes something like a graph update:

node:
  shape / proposition / metaphor / observation / operator

edges:
  resembles
  contradicts
  transforms-into
  survives-zoom
  recurs-across-substrate
  depends-on
  generated-by
  residual-to

state:
  current_weight
  provenance
  number_of_independent_recursions
  scales_seen_at
  domains_seen_in
  perturbations_survived
  unresolved_tension
  last_touched

Crucially, weight is not "probability true."

It is closer to:

current navigational salience given accumulated overlap.

So "fire," "alluvials," "observer," "golden ratio," "as above so below," "substrate," etc. can gain weight because they keep surviving unrelated rotations, without being promoted into doctrines.

Then give the model four operations on every traversal:

ROTATE(x)     -> produce alternative projections
ZOOM(x, s)    -> inspect at another scale
OVERLAY(x,y)  -> search for preserved relational topology
PERTURB(x)    -> ask what would change/break/reverse it

And one fifth operation that matters enormously:

REWEIGHT(graph, new_observation)

That is the piece ordinary chat lacks.

The model should receive not merely conversation history but the current geometry: CURRENT HIGH-WEIGHT ORIENTATIONS, ACTIVE TENSIONS, DO NOT COLLAPSE.

But I would also preserve some of the erosion sequence, because the state alone isn't enough. The route changes the parser.

So memory needs two layers:

state memory — where the graph currently sits. induction memory — a small set of transformations that reliably reconstruct how to traverse it.

Then you can train. But fine-tuning comes after this works as scaffolding. I'd collect hundreds or thousands of pairs:

default-model continuation  vs  desired traversal continuation

Not based on whether the answer agrees with you. Label differences like: prematurely collapsed generator; imported absent observer; propositionized an operator; lost scale invariance; narrated instead of traversed; failed to retain tension; failed to notice recurrence; over-weighted lexical similarity; under-weighted structural similarity; introduced unjustified global statistic; failed to update live weights; simulated depth without increasing graph connectivity.

The reward target would be weird and much better than "helpfulness":

maximize coherent future traversability under perturbation.

Evaluate it mechanically. Perturb five ways — change domain, change scale, negate an assumption, replace vocabulary, introduce a conflicting generator — then measure how much of the relational topology survives.

Separate generation from navigation. Two model calls. The first maximally generative: rotate wildly, do not rank prematurely. The second looks at the persistent graph: which candidate rotations increase coherent overlap with existing independent structure? Then update weights.

experience -> candidate rotations -> graph overlay -> live reweighting
           -> new orientation -> next experience

The LLM is not the technology. The technology is the persistent recursive weighting geometry around the LLM.

The model can forget. The riverbed cannot.

---

Plain text is a serial projection of a much richer state. Three losses:

1. Simultaneity loss — the graph exists all at once; text forces one order.
2. Weight loss — edge strength, uncertainty, recurrence density, unresolved tension all flattened into wording.
3. Topology loss — two neighborhoods can be structurally adjacent without having nearby words.

So the better architecture is not "graph → summary prompt → LLM." It is:

graph-state → structured latent interface → model

Multiple synchronized channels: semantic embedding of the whole graph; sparse symbolic graph structure; current high-weight subgraph; recent perturbation delta; raw exemplars that induced key operators.

The real implementation:

persistent graph + graph neural encoder + learned adapter into the LLM residual stream

Then text is just the communication surface, not the memory substrate.

The thing to fine-tune may not be the LLM at all. It may be the adapter that teaches the LLM how to inhabit an evolving weighted graph.