Layer 2

Holarchy of Agency
of Mind and Perfunction

A BST grown by mitotic binary division. Each node is a Holon - simultaneously a complete agency unit and a part of a larger mission structure. The perfunctor path stored in every JSONL record is not a label. It is the Holon's identity, its BST address, and its forward-conditioning signal for the next Now.

The Holon - Whole and Part

Arthur Koestler coined the term holon for any entity that is simultaneously a whole in itself and a part of a larger whole. A cell is complete - it has its own metabolism, membrane, and function. It is also a constituent of a tissue, which is a constituent of an organ, which is a constituent of an organism. It is not merely a building block, and it is not merely a subsystem. It is both at the same time, fully.

The Timeline Paradigm applies this structure to agency. Every Holon in the BST is a complete agency unit: it has its own TimeField partition, its own Clio iteration, its own forward seed, its own perfunctor path. It operates semi-autonomously. It is also a node in the BST - one part of the larger Holarchy, one branch of the mission, one partition of the total morpheme space. Neither description supersedes the other.

As a whole

Complete agency unit. Its own TimeField partition. Its own Clio iteration running Markovian transitions across its own ranked sequence. Its own forward seed past its own Now Horizon. Semi-autonomous. Internally coherent.

As a part

One node in the BST. One branch of the mission perfunctor. Its partition of the morpheme space was defined at the moment of mitotic division from its parent. Its path key encodes its position in the full Holarchy. It does not stand alone.

The Holon's perfunctor path key is stored directly in every JSONL record it produces. The path is not appended as metadata - it is the holon field, one of the four compliance contract fields. Every Now emitted by a Holon carries the Holon's identity into the TimeField substrate. The record and the agency structure are inseparable.

The BST - Grown by Mitosis

The Holarchy is a binary search tree. It is not designed upfront and populated. It grows by mitotic division: when a Holon's semantic density crosses the efficacy threshold, the heartbeat observer fires and the Holon divides. The BST acquires a new level. The parent becomes an internal node. Two child Holons become the new leaves.

The path key encodes the full history of divisions that produced a given Holon. root.L.R.L means: from root, the left partition at first division; from that partition, the right at second division; from that, the left at third. The path is the provenance. It is also the address. It is also the forward-conditioning signal embedded in every Now the Holon emits.

// Holarchy BST - grown by mitotic division

root
├── root.L             morpheme partition A
│   ├── root.L.L         partition A · older Nows
│   └── root.L.R         partition A · recent Nows
│       ├── root.L.R.L    ← you are here
│       └── root.L.R.R
└── root.R             morpheme partition B

// Each node is a live Holon with its own TimeField partition.
// Path length = number of mitotic divisions from root.
// No external registry. The path IS the identity.

The BST is rhizomatic at the forest level: the PointerForest holds multiple roots and any node can branch to any other. But within a single Holarchy, the path key provides strict hierarchical provenance. The two structures are not in conflict - the PointerForest's rhizomatic traversal and the Holarchy's path-keyed BST operate at different levels of the same system.

The Efficacy Threshold - When Mitosis Fires

A Holon divides when its semantic density crosses the efficacy threshold. Semantic density is not a count of records. It is a measure of how compressed the morpheme space within the Holon's TimeField partition has become - how many distinct morpheme categories are active, how frequently they co-occur, and whether the embedding-space variance within the partition is increasing faster than Clio can resolve it by ghost extraction.

When density exceeds the threshold, the Holon is no longer able to maintain clean anticipatory seeding. The forward seed becomes ambiguous: multiple morpheme categories compete for the next-state position and the cosine similarity between the seed and any actual incoming Now is consistently below the confirmation threshold. The Holon is overloaded. Mitosis is the resolution.

  1. Threshold crossed. The heartbeat observer fires. Semantic density metric exceeds the configured efficacy floor. The current Holon's partition is flagged for division.

  2. Partition computed. The existing TimeField records in this Holon are ordered by tNdx. The median tNdx value is the split point. Older Nows go to the left child; recent Nows go to the right. The split is temporal, not semantic - but because the embedding space drifts over ranked time, the temporal split produces a meaningful semantic partition.

  3. Child Holons instantiated. Two new HolonNode objects are created. Left child path = parent path + .L. Right child path = parent path + .R. Each child receives its TimeField partition. Each child initialises its own Clio instance with an empty transition matrix - it will be rebuilt from its inherited records on the first iteration.

  4. Forward seed resolved. If a pending forward seed existed at division time, it is assigned to the child Holon whose embedding centroid is most proximate to the seed's embedding vector. The seed is not discarded. Its tNdx is in the record. It continues to wait for confirmation in the child's partition.

  5. Parent retires to internal node. The parent Holon no longer emits new Now records. It becomes a structural node: it holds the path keys of its children, the tNdx of the division event, and the inter-partition ghost log from any subsequent IterateStereo runs across its two children.

No record is rewritten at division. The existing JSONL records in the parent's partition keep their original holon field value (the parent path). They are queryable by that path forever. The child Holons hold pointers to them via the PointerForest - the records themselves are immutable.

The Divide Operation

root.L.R  ·  semantic density threshold crossed  ·  dividing
tNdx median split | older → L    recent → R
Left child
root.L.R.L
Older Nows from the parent partition. Lower tNdx values. Clio re-initialised. Transition matrix rebuilt from inherited records.
Right child
root.L.R.R
Recent Nows from the parent partition. Higher tNdx values. Clio re-initialised. Forward seed assigned here if embedding is proximate.
// Divide performs mitotic binary division of a HolonNode. // Returns (left, right, error). Parent becomes an internal node. func (hn *HolonNode) Divide() (*HolonNode, *HolonNode, error) { records := hn.forest.RecordsByHolon(hn.Path()) if len(records) < 2 { return nil, nil, ErrInsufficientRecords } // Split by tNdx median sort.Slice(records, func(i, j int) bool { return records[i].TIndex() < records[j].TIndex() }) mid := len(records) / 2 // Instantiate children left := NewHolonNode(hn.Path() + ".L", hn.forest, records[:mid]) right := NewHolonNode(hn.Path() + ".R", hn.forest, records[mid:]) // Resolve pending forward seed to nearest child if hn.clio.currentSeed != nil { seed := hn.clio.currentSeed dL := cosineDistance(seed.Embedding, left.Centroid()) dR := cosineDistance(seed.Embedding, right.Centroid()) if dL <= dR { left.clio.currentSeed = seed } else { right.clio.currentSeed = seed } } // Log division event to parent hn.divisionTNdx = nowMicro() hn.children = [2]*HolonNode{left, right} hn.retired = true return left, right, nil }

Perfunction - The Path as Forward Condition

The word perfunction names the property that makes the Holon's path key more than a label: it is a forward-conditioning signal. Every Now record a Holon emits carries the Holon's path in the holon field. That field is used as the BST address, the partition key, and - critically - as an input to the embedding endpoint that generates the record's embedding vector.

Because the embedding is conditioned on the Holon path, the embedding space of a deeper Holon (longer path key, more divisions from root) is a specialised subspace of its ancestors' embedding spaces. The path conditions the future before the future arrives. The Holon is already shaping the next Now's semantic position by being the Holon it is.

Path as perfunction - what each level encodes
root
The full mission embedding space. No prior division. Every morpheme category is reachable. The Now Horizon spans the full vocabulary.
root.L
One division from root. The older-tNdx partition. Embedding space narrowed to the morpheme categories that dominated the early TimeField.
root.L.R
Two divisions. The recent-Nows sub-partition of root.L. A further specialisation of the earlier narrowing. Embedding space is denser and more specific.
root.L.R.L
Three divisions deep. A highly specialised agency unit. Its embedding space is a narrow subspace of its ancestors'. Its forward seeds are precise. Its Now Horizon is tight. Salience threshold for ghost extraction is elevated - only high-proximity morphemes fruit at this depth.

The perfunctor path stored in the JSONL record is therefore a complete provenance record, a live address, and a semantic constraint on what comes next - all in a single string field. This is why the compliance contract requires it, and why no external registry of Holon structure is needed. The record IS the registry.

// The holon field in a JSONL record is never decorative. // It carries three simultaneous roles: // 1. BST address - used by the PointerForest to route traversal record.HolonPath() // → "root.L.R.L" forest.Root("root.L.R.L") // → retrieves this Holon's root node // 2. Partition key - used by Clio to collect the TimeField slice c.collectPartition(holon) // filters records where holon == path // 3. Forward-conditioning signal - passed to the embedding endpoint // The embedding model receives the holon path as context. // The resulting embedding vector is shaped by it. // The path conditions the next Now before it is written.

Inter-Holon Ghosts - What Lives at the Division Boundary

When a Holon divides, a new structure comes into existence that belongs to neither child: the inter-partition ghost. This is the morpheme that sat at the tNdx median - neither old enough to belong to the left child nor recent enough to belong to the right. It exists at the division boundary itself.

Clio's IterateStereo finds these ghosts after each division. It computes the embedding centroids of the left and right child partitions and looks for morphemes equidistant from both - belonging fully to neither, emerging from the disparity field between the two new agency units. These are the morphemes that the division itself produced: not present in either child's partition, but constituted by the act of splitting.

// After Divide(), run IterateStereo across the two children // to recover the inter-partition ghost morphemes. left, right, _ := parent.Divide() stereoGhosts := clio.IterateStereo(left, right) // stereoGhosts: morphemes at the division boundary. // They belong to neither child. // They are logged to the parent's ghost record // with holon = "stereo:root.L.R.L:root.L.R.R" // They are queryable by the PointerForest's GhostInterval. // They are the signal that the division itself was meaningful.

If a division produces no inter-partition ghost morphemes above the salience floor, that is diagnostic: the division may have been premature, or the efficacy threshold may be miscalibrated. A meaningful mitotic split always produces at least one ghost at the boundary - the morpheme that belonged to neither partition but was generated by the conceptual clarification that the division represents.

The Holarchy provides the topology. Clio - documented in → Clio - runs the chemistry that iterates across it. The theoretical foundation for the ranked-occurrence substrate both operate on is in → Paradigm.

Go struct definitions and method signatures for HolonNode and Divide() are in → Reference.

Those who have read this far and want to follow the architecture to what it describes at the level of the paradigm itself - → there is a deeper reading.