Canonical · Relation to Adjacent Work

LLMs, Agents, and Sovereignty

Between “just autocomplete” and “a person” — the framework draws the line where it belongs

Public argument about large language models swings between two poles: on one side, “it is only predicting the next token”; on the other, “it is effectively a mind.” The debate is stuck partly because it has no agreed criterion for what would settle it. This framework supplies one — not a test for intelligence or consciousness, which it does not claim to adjudicate, but a structural test for what kind of thing a given AI system is with respect to self-maintenance. Applied carefully, it separates three cases the debate runs together: a bare model doing a single pass, which barely raises the persistence question at all; an agent wrapped in a loop, which raises it genuinely; and the question of whether any of it is sovereign. The short verdict, argued below, is that most systems people call “AI agents” today are recursive but not sovereign — the same class the framework assigns the prion: a real self-referential loop whose boundary and upkeep are supplied from outside.

Why classical framing gets stuck

The trouble is that both poles of the debate are pointing at real features and neither has a boundary criterion. “Just autocomplete” correctly notes that the underlying model is a fixed function computing a next-token distribution. “Effectively a mind” correctly notes that a looped, tool-using system can pursue goals over many steps, keep notes, and revise its own plans. Both observations are true of different objects, and the argument conflates them. Without a criterion that says which object we are talking about and what it would take to persist as a self, the exchange cannot resolve. [verify characterizations of model and agent behavior against current technical literature]

What the framework refuses to do. It does not offer a test for intelligence, understanding, sentience, or moral status. Those are real questions and this is not the instrument for them. The framework tests exactly one thing: whether a configuration is a self-maintaining recursive structure — and if so, whether its self-maintenance is its own or supplied. That is a narrow, structural question, and keeping it narrow is what lets it be answered at all. Any reading of this page as a verdict on machine minds is a misreading.

Three objects the debate runs together

The base model, one forward pass — a bare fixed map. A trained model computing a single next-token distribution is a fixed function evaluated once. Nothing is looping; nothing is maintaining itself; no boundary is being held. In the framework's catalogue this is closest to the random-Boolean-network case: a computation of a fixed map, for which the question “who is paying to keep it there?” barely applies, because nothing is being kept there. It is neither sovereign nor an attractlet; it is a bare evaluation. The “just autocomplete” pole is describing this object, and about this object it is roughly right.
The agent scaffold — genuine recursion. Wrap that same model in a loop — feed its output back as input, give it memory it writes and reads, tools it calls, the ability to invoke itself — and you now have a structure whose present state is a function of its own prior states. That is real self-reference; the loop closes. So the bare-map verdict does not transfer: an agent is not “just autocomplete” any more than a cell is “just chemistry.” The recursion is genuine, and it is exactly the kind of thing the framework is built to classify. The “effectively a mind” pole is pointing at this object — but it overshoots, because recursion is not sovereignty.
The two poles are not disagreeing about one thing; they are describing two different objects. “Just autocomplete” is true of the single forward pass. “It has real recursive dynamics” is true of the looped agent. Neither settles whether the agent is sovereign — and that is the question that actually carries the weight.

The verdict: recursive, but not sovereign

Run a typical present-day agent through the four sovereignty conditions and it clears the first ones and fails the decisive ones — the same pattern the framework found in the prion.

Condition 1 (Recursion Lock) — plausibly met. The loop closes: output feeds input, the system continues across steps rather than being re-created from nothing each time. There is genuine closed-loop feedback.
Condition 2 (Internal Recurcline Persistence) — partially, and worth watching. An agent with working memory or a scratchpad carries some identity across steps and can recover from a local misstep. How much genuine identity persists — versus how much is re-supplied each turn from a prompt template — is exactly the kind of thing the framework would want measured rather than assumed. [verify the extent of within-run state persistence in current agent architectures]
Condition 3 (Boundary Retention) — fails. This is the decisive one. The agent has a boundary — its context window, its identity, the scope of what it treats as “itself” — but it does not self-produce that boundary through its own activity. The boundary is drawn and enforced by an orchestrator: the harness that decides what goes in the context, when the run starts and stops, what the system is. A handed-in boundary is precisely what the boundary-stabilizing pivot (AC₁₁) requires and does not have here. The edge that gives the agent its identity is supplied, not made.
Condition 4 (Maintenance-Bearing Continuation) — fails. The upkeep is offloaded. The agent runs at real cost — compute, energy, the loop itself — but it does not pay that cost out of its own activity. A host process supplies the compute, schedules the loop, and keeps the lights on. Cut the host and the agent does not fight to persist; it simply stops. It runs at cost, and the cost is paid from outside — the exact split the sovereignty page uses to separate a machine plugged into the wall from a cell that earns its own keep.

A present-day AI agent has the loop but not the self-made boundary and not the self-borne bill. That places it in the framework's third category, alongside the prion: recursive but not sovereign — a genuine self-referential structure whose boundary and maintenance are supplied by a host. It is not “just autocomplete” (the recursion is real) and it is not a self-sustaining agent in the strong sense (the sovereignty is absent). It is the thing in between, and the framework has a name for it.

What this buys

The stuck debate comes unstuck. Once the three objects are separated and the four conditions applied, the “autocomplete versus mind” impasse dissolves into a set of answerable questions: Is there a loop? (For an agent, yes.) Does it self-produce its boundary? (Currently, no — the harness does.) Does it pay its own maintenance? (Currently, no — the host does.) None of these requires deciding whether the system “really understands.” The framework replaces an unwinnable argument with a structural checklist that has definite answers.
And it names what would have to change. The verdict is about current systems, and it points precisely at what a sovereign AI structure would require: it would have to self-produce and defend its own boundary rather than receive it from an orchestrator, and bear its own maintenance rather than offload it to a host. Those are the two open conditions. Whether a system can be built that meets them — that decides what is in its own context, that secures its own continuation — is a genuine research frontier, not a thing today's agents do. The framework does not claim it is impossible; it states exactly which two conditions stand between a recursive agent and a sovereign one.
What the framework does not claim. It does not rank systems by capability, and non-sovereign does not mean unintelligent, unimpressive, or unimportant — the prion and the engine are both non-sovereign and both consequential. It does not adjudicate understanding, sentience, or moral status. And it does not assert that any particular product is or is not sovereign; that requires applying the four-condition test to the specific architecture, which is an empirical exercise the framework frames but does not perform here.
Where this sits, and what it leaves open. This page reads one debate through one classification: separating the base model (a bare fixed map) from the agent (genuine recursion), and finding the agent recursive but not sovereign — the prion's category, arrived at through the same two failed conditions. Threads deliberately left open:
  • Capability “emergence” with scale — whether abilities appear at a threshold or ramp smoothly — is the AI counterpart of the origin-of-life question and belongs with the framework's discrete-existence claim; it is treated separately from this classification page and pairs with autocatalytic sets. [verify against the emergence literature]
  • Attractor dynamics inside neural networks — the settling of recurrent and transformer activations into stable states, and what can be observed about them only from within their basin — is a distinct, more technical case the framework also speaks to, reserved for its own treatment. [verify]
  • Training and model collapse — mode collapse, policy collapse, and collapse from recursive self-training — read in the framework as loss of the ambient inflow a non-self-sufficient loop depends on; a candidate future entry. [verify]
  • Could an AI structure be built to satisfy Conditions 3 and 4? The two open conditions define the frontier; whether they can be met by a system that authors its own boundary and secures its own continuation is left as a genuine question, not prejudged.
None of this touches the framework's fixed foundations; the six substrate conditions are closed and are not at issue on this page.
Adjacent-work assessments state where Principia Attractum agrees with and departs from neighboring phenomena and frameworks. They introduce no constructs and modify no canon; they locate the framework relative to its field. The classification of a single forward pass as a bare fixed map, of an agent scaffold as genuine recursion, and of present-day agents as recursive but non-sovereign, are downstream applications of the framework's existing distinctions, not additions to it. The framework offers no test for intelligence, understanding, sentience, or moral status, and no such claim should be read into this page. Technical characterizations of models and agents are marked [verify] and should be confirmed against current primary literature before publication; the field moves quickly.
← Back to Relation to Adjacent Work