# 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:

```text
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:

```text
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:

```text
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:

```text
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.

```text
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**.