Base, Coordination, and Sovereign
The three-class attractor taxonomy, and where the coordination attractor sits
“Attractor” in this framework is not one kind of thing. It names three, and they form a graded taxonomy: a base attractor whose loop merely closes, a coordination attractor that organizes many parts without holding itself together, and a sovereign attractor that produces and defends its own boundary and pays its own way. The companion pages set the two dramatic ends against each other — the sovereign attractor and the attractlet it is not. This page fills in the middle, because the middle is where most real recursions live, and because one class in it — the coordination attractor — is the most organized thing the framework will still refuse to call sovereign.
A note on the word “attractor.” This page uses the word at its broad width: all three classes below — base, coordination, and sovereign — are attractors, genuine recursions distinguished by what each one's activity has built. The companion What Is an Attractor page uses the same word at its reserved width, where “attractor” alone means the sovereign case. Both are canonical; they are two scopes of one word, not two definitions. So nothing here contradicts that page — a base or coordination attractor is exactly a recursion that has not reached the reserved sense. Where it matters we write sovereign attractor in full. The attractlet sits outside this taxonomy entirely: it is non-recursive, and is never an attractor at either width.
Why three, and along what axis
The three classes are distinguished by a single question: what has the recursion's own activity managed to build? Not how large it is, not how long it has lasted, not how successfully it coordinates — but which of the sovereignty conditions its own operation has come to satisfy. Read that way the taxonomy is not a ranking of importance; it is a reading of structure. A base attractor has closed a loop. A coordination attractor has, on top of that, integrated many loops into a persistent, self-correcting network. A sovereign attractor has, on top of that, crossed the one line the other two have not: it makes and holds its own identity-bearing boundary and bears its own maintenance.
Everything below is a downstream reading of the four sovereignty conditions. The classes differ in how many of those conditions the structure's own activity has come to satisfy, and the decisive divide — the one that separates the whole recursive middle from sovereignty — is Condition 3, the self-produced boundary.
ATX-BASE Base attractor
The loop closes, and nothing more.
The simplest genuine recursion: a closed feedback loop that regenerates its own enabling components. Its present state feeds its next state and the loop has closed, so it is a real attractor and not something driven from outside. But it has developed no further — no integration of many loops, no self-made boundary, no self-borne maintenance beyond the bare closure. Most attractors are of this kind and stay this way; stalling here is the default, not a defect.
- Condition 1, Recursion Lock — the closed loop is exactly this condition.
- Conditions 2–4 — not developed. A base attractor has the loop but not the persistence machinery, the self-made boundary, or the borne maintenance that the higher classes add.
A set of molecules whose reactions regenerate their own catalysts — the loop's product is the very thing that speeds the loop. While its feed molecules last, its own activity raises the probability that the same activity happens again: that is a closed feedback relation, and a genuine attractor, not a pattern pushed from outside. But look at what it has not built. It channels no population of distributed parts into a shared pattern (nothing to coordinate). It manufactures no boundary of its own — if it is bounded at all, some external vessel is doing the bounding. It bears no maintenance beyond the bare fact of turning over. It is exactly a loop that closes and nothing more, and it can run this way indefinitely without ever becoming anything else. Why base: single feedback relation raising its own persistence — no coordinated population, no self-made edge.
ATX-COORD Coordination attractor
Organizes many parts — and still does not hold itself together.
A recursion that stabilizes multi-agent coordination: it integrates two or more cross-feeding loops into a stable, self-sustaining network — a basin of persistence — and can correct its own local deviations rather than dissolve at the first shock. It is genuinely more than a base attractor: it holds an identity across perturbation, it channels and aligns the activity of its parts, it can be elaborate and long-lived and manifestly organizing. This is the class that looks, to an outside eye, like it is “in control” of something.
And it is still not sovereign. A coordination attractor fails the decisive condition: it does not produce and defend a boundary of its own. It organizes its parts, but the edge that gives it identity is not something its own activity manufactures and holds. It can coordinate a great deal, indefinitely, and never cross into sovereignty. Coordination scale and coordination success are not evidence of sovereignty — a point the framework is emphatic about, because the temptation to read “organizes a lot, very well” as “therefore self-maintaining” is exactly the error the class exists to catch.
- Condition 1, Recursion Lock — genuine closed-loop recursion.
- Condition 2, Recurcline Persistence — holds an identity across bounded perturbation; recovers from local deviation.
- Condition 3, Boundary Retention — the decisive failure. It does not self-produce its own identity-bearing boundary.
- Condition 4, Maintenance — may run at cost, but without the self-made boundary of Condition 3 it is not sovereign regardless.
A price for some good, emerging from the trades of thousands of buyers and sellers who never coordinate directly. Its whole function is to lower the cost of coordination across a distributed population: a single number lets strangers align supply with demand without negotiating pairwise, and the more the price successfully clears the market, the more everyone relies on it — a self-reinforcing loop whose payoff is collective, reducing negotiation and signalling cost across all the parts at once. This is a real recursion and a formidably organized one. It is also, precisely, not sovereign. The price produces and defends no boundary of its own; there is no membrane whose breach would kill “the price” as an identity. It organizes its participants without ever holding itself together — the source of its coherence is the ongoing activity of the traders, not an edge it manufactures and maintains. Why coordination, not sovereign: dominant effect is cutting coordination cost across many parts — and note the trap the class exists to catch, that organizing an enormous market is volume, not boundary-making. Scale is not sovereignty.
ATX-SOV Sovereign attractor
Makes its own boundary, pays its own way.
The full case, treated at length on its own page: all four sovereignty conditions hold at once. To the coordination attractor's closed loop and self-correcting persistence it adds the two the middle lacks — a boundary it produces and defends by its own activity, and a maintenance cost it bears from within. It is self-sustaining in the strict sense the framework means: the source of its persistence is inside the boundary, not outside it.
- Condition 1, Recursion Lock — closed loop.
- Condition 2, Recurcline Persistence — stores its own recursion and recovers from shock.
- Condition 3, Boundary Retention — produces and defends its own identity-bearing boundary. This is the line the middle does not cross.
- Condition 4, Maintenance — bears the ongoing cost of its own continuation, paid from within.
A single cell holds the whole picture at once. It runs closed metabolic loops (the base). It coordinates thousands of distributed molecular processes into a self-sustaining, self-correcting network (the coordination). And then it does the two things the market price could not: it builds and repairs its own membrane — an identity-bearing boundary its own activity manufactures and defends, whose breach is the death of this cell, not merely of a part — and it bears its own maintenance from within, spending its own resources to keep the conditions of its own continuation satisfied. Its molecules turn over constantly; the same cell persists across that turnover because its identity lives in the self-maintained regime, not in any particular contents. The source of its persistence is inside the boundary. That is sovereignty in the strict sense. Why sovereign: it regulates its own admissibility conditions and holds its own self-made edge across local turnover — the line the market never crosses.
The three examples, side by side
The same three cases, read across the axis that separates the classes — what each one's own activity has managed to build. Read left to right, each class keeps everything to its left and adds one thing more; the decisive addition is the self-made boundary, in the last column.
| Class | Example | Closed loop | Coordinates a population | Self-made boundary & self-borne upkeep |
|---|---|---|---|---|
| ATX-BASE base | an autocatalytic chemical cycle | yes | no | no |
| ATX-COORD coordination | a market price mechanism | yes | yes — its dominant effect | no — the line it never crosses |
| ATX-SOV sovereign | a living cell | yes | yes | yes — makes and repairs its own edge, pays its own way |
Read the rows, not a ranking: the chemical cycle is a complete base attractor and the price a complete coordination attractor — neither is a failed cell. The table records what each structure is, which is exactly what its own activity has built.
The line that matters: the self-produced boundary
ATX-COORD to ATX-SOV turns on a single mechanism: the structure beginning to self-produce and maintain the boundary that enables its own continuation. Before that, however much it coordinates, its identity-bearing edge is not its own doing. After it, the structure regulates its own conditions of admissibility through its own activity — and that is what sovereignty is. This is the whole difference between the most organized non-sovereign attractor and the least dramatic sovereign one, and it is a threshold, not a slope: the boundary is either self-made or it is not.The taxonomy is graded, but it is not a value ladder
Two further cautions the framework attaches to the ordering, so it is not misread as a conveyor belt:
The transitions are not automatic, in either direction. Not every coordination attractor becomes sovereign — most do not. And not every sovereign attractor was once a coordination attractor; a sovereign structure can arise by other routes. The classes are a taxonomy of what is, not a mandatory life-cycle.
Sovereignty can be lost back into the middle. An established sovereign attractor that ceases to self-produce its boundary does not merely weaken — it undergoes a real loss of sovereignty and regresses to a coordination attractor: still organized, still persisting, but no longer holding itself together. What returns afterward, if anything, must re-establish the self-made boundary from scratch; the sovereign identity is not inherited back across that break.
How the classes relate to the bootstrapping path
The bootstrapping modes describe how a structure could build its way up this taxonomy — the spine of modes is the canonical (partial, not guaranteed) path from base through coordination to sovereignty:
The taxonomy classifies attractors by what they have become; the bootstrapping modes classify the self-reinforcing dynamics by which they might get there. They are related but distinct: the modes are the possible path, the classes are the standing structure. Crucially, AC11 — boundary-stabilizing autocatalysis — is the mode that carries a coordination attractor across the line into sovereignty.
Coordination and sovereignty are not alternatives
One last correction, because the three-way split can be misread as three mutually exclusive boxes. A sovereign attractor does not replace coordination; it very often employs it. Coordination attractors routinely appear as substructure inside sovereign ones — a sovereign attractor may coordinate many parts as part of how it maintains itself. So “coordination” and “sovereign” are not opposed options; the question is whether, on top of whatever coordination is present, the structure also makes and holds its own boundary. And a coordination attractor is emphatically not an attractlet: it is a genuine recursion, not something held together from outside. The three attractor classes all recurse; the attractlet is the separate, non-recursive contrast category that sits outside this taxonomy entirely.
Base, coordination, sovereign: a loop that closes, a loop-network that organizes, and a recursion that makes its own boundary and pays its own bill. The coordination attractor is the high-water mark of the recursive middle — the most a structure can organize without yet holding itself together — and the line it has not crossed is the same line the whole framework is built around.
See also: the two ends of the picture in full — What Is an Attractor (the sovereign case) and What Is an Attractlet (the non-recursive contrast); the four sovereignty conditions the classes are read against; the bootstrapping modes that describe the path up the taxonomy; the recursive-but-non-sovereign middle as it appears in real cases (prions, AI agents); and the two-register account in Attractors versus Attractlets.