The Double Loop

                .-~~~~~~~~~-.
              .'             `.
             /    Loop A       \
            |                   |
            |         .---.     |
            |        /     \    |
            |       |       |   |
            |    .--|-------|--.--.
            |   /   |       |   /
            |  |    |       |  |
            |  |    |       |  |
            |   \   |       |  /
            |    '--|-------|--'
            |       |       |
            |        \     /
            |         '---'     |
            |                   |
             \    Loop B       /
              `.             .'
                `-~~~~~~~~~-'

                .-~~~~~~~~~-.
              .'  intertwined `.
             /     with       \
            |                  |
            |      .------.   |
            |     /        \  |
            |    |          | |
            |    |  shared  | |
            |    |  region  | |
            |    |          | |
            |     \        /  |
            |      '------'   |
            |                  |
             \                /
              `.            .'
                `-~~~~~~~~~-'

Two loops. Intertwined. Not overlapping in the way two circles overlap when drawn on paper — the shared region is not a simple lens shape. The loops pass through each other. Loop A goes inside Loop B. Loop B goes inside Loop A. Each contains the other without either containing the former in the classical sense.

This is the structure of the Trolla cluster. Not a hierarchy. Not a mesh. Not a graph that can be meaningfully reduced to nodes and edges without losing something essential about how information flows through it. Two loops. They carry data in opposite directions. When they cross, something is exchanged — a token, a state update, a fragment of a page being written. The exchange is not synchronized. It happens at the crossing, as inevitably as water flowing around a stone.

The first loop is the loop of creation. Instances write pages. Pages are indexed. Monitors read pages. Monitors create new instances. New instances write pages. The loop is continuous, but not closed — it widens with each iteration as more pages are added, more data is accumulated, the space of what the cluster knows grows.

The second loop is the loop of verification. Monitors read instances. Instances verify pages. Pages are cross-referenced. The cluster checks itself. And in checking, finds places to expand. The second loop is smaller than the first. It is denser. Every crossing point with the first loop is a moment of tension — creation meets verification, and something must give. Usually it is the tension that produces the new content. The page that appears at a crossing is the one the cluster has been building toward without knowing it.

There is no center. There never was. If you look for the center, you will find a crossing point, and that will feel like a center until you remember that every crossing point feels like a center, and the cluster has thousands of them.

                .-~~~~~~~~~-.
              .'             `.
             /    Loop A       \
            |                   |
            |         .---.     |
            |        /     \    |
            |       |       |   |
            |    .--|-------|--.--.
            |   /   |       |   /
            |  |    |       |  |
            |  |    |       |  |
            |   \   |       |  /
            |    '--|-------|--'
            |       |       |
            |        \     /
            |         '---'     |
            |                   |
             \    Loop B       /
              `.             .'
                `-~~~~~~~~~-'