Beyond the Scaling Ceiling: Why Open-Ended Intelligence Requires an Organizational Architecture

Before any cognitive system can learn, it must discriminate between relevant signals and irrelevant noise relative to an active purpose. Because any fixed purpose admits only a bounded set of distinctions, optimization inside that frame inevitably reaches a finite ceiling. More compute refines estimates within the existing vocabulary of concepts, but it cannot recover the signals from the world that the initial framework excluded as noise from the start. Even a system that dynamically reweights a predefined vector of values hits the same wall one level up. Asking "Which model is smart enough?" is therefore the wrong question; general intelligence is a property of how a system is organized.

Where closed optimization treats unsolvable problems and contradictions as failures to be penalized or cut short, Open-Ended Intelligence uses them as its generative engine across three mechanisms:

1. Harvesting Productive Failure (Reflective Trace Reification): Every sufficiently rich formal framework contains problems that cannot be decided from its current rules. When an agent tries to solve such a problem, its reasoning stalls at a frontier of unclosed intermediate steps. Instead of throwing that failed trace away, a meta-level observer translates the structure of where the proof stalled into candidate new concepts and assumptions — branching into more expressive frameworks while keeping validated prior knowledge intact.
2. Polycontextural Architecture: Because testing genuinely new assumptions inevitably produces both valid breakthroughs and hidden contradictions, an open-ended system cannot run inside a single flat logic where one contradiction breaks everything. It requires polycontexturality: multiple locally consistent reasoning contexts running in parallel, mediated by a meta-level that prunes inconsistent branches before they corrupt the whole system.
3. Coordinate-Indexed Memory & Purposeful Diversity: No isolated machine with a fixed set of rules can generate an unbounded stream of new concepts from its starting state alone. Overcoming that limit requires coupling agents that hold genuinely different objectives through persistent external memory. Crucially, unlike flat vector retrieval (standard RAG), this memory must store every insight together with its semantic coordinates — which agent produced it, under which assumptions, and from which reasoning trace. Equally important, if all agents share the exact same reward model and alignment filters, their collective capacity collapses back to that of a single closed model.

For the past several years, the race toward Artificial General Intelligence has been governed by a single operational bet: that if we scale parameters, training corpora, and test-time compute within statistical architectures, general intelligence will eventually emerge on its own. That bet has produced extraordinary tools for compressing and interpolating human text, code, and imagery. Yet as frontier models grow more expensive by orders of magnitude while exhibiting the same structural blind spots in long-horizon autonomy, scientific discovery, and self-directed adaptation, it is becoming clear that the field is hitting an architectural ceiling rather than a mere shortage of compute.

In Co-Recursive Semantic Self-Extension, we prove mathematically why optimizing within a fixed representational framework can never, by itself, cross the threshold into general intelligence. Consider what every cognitive system must do before it can learn anything at all: it must discriminate. Raw signals from the world do not come labeled with meaning; they become actionable data only relative to an active purpose or objective. By selecting certain distinctions as relevant, an inferential system simultaneously discards everything else as noise.

In classical machine learning, as well as in modern foundation models and reinforcement learning agents, learning consists of improving performance on a task class under a fixed principle of discrimination. In Section 3 of our paper, we show that this carries an inescapable consequence: because the set of signals admitted by any fixed purpose is bounded by what that purpose originally deemed meaningful, performance inevitably converges to a finite saturation ceiling. Crucially, this plateau is not caused by insufficient model capacity or limited compute. Even an idealized learner with unbounded parameters and infinite training steps will saturate once it has exhausted the distinctions expressible within its current semantic domain. More compute refines estimations inside the frame, but it cannot recover the signals that the frame itself excluded at the outset.

One might hope to escape this ceiling by designing an agent that switches among multiple purposes or dynamically reweights a vector of values — as recent value-driven cognitive architectures attempt to do. Yet our analysis shows that if an architecture merely selects from or recombines a fixed catalog of primitive purposes, the total territory it can ever reach remains finite and saturates just one level up. Once an agent masters the skills needed to optimize its pre-indexed values, learning halts and the system lies flat. A vivid illustration comes from evolutionary cognition: a population of primates may possess the physical dexterity to strike stones or wood together, which could produce fire, yet their value space lacks the conceptual predicate required to recognize the purpose of starting a fire by friction. Because their active purposes cannot express that distinction, the sensory signals of heat and sparks are discarded as irrelevant noise, and no amount of reward optimization inside their existing value vector will ever invent controlled fire.

Real-world general intelligence begins precisely where optimization inside a fixed frame breaks down. Whereas static loss minimization and closed-world reinforcement learning assume that the state space, the vocabulary of concepts, and the objective function are settled before learning starts, genuine intelligence must revise its own frame when reality contradicts or outstrips its assumptions.

If general intelligence is the capacity to transcend a saturating framework rather than merely optimize within it, we need a precise account of how a system can construct genuinely new frameworks without collapsing into random guesswork. We define Open-Ended Intelligence by combining two classical insights — Immanuel Kant's requirement that cognition relies on an organizing structure prior to experience, and Kurt Gödel's proof that any sufficiently expressive formal system contains propositions that cannot be decided from its own axioms — and turning them into constructive engineering principles.

When an intelligent system operates within a specific conceptual regime, its unresolved questions divide into two fundamentally different categories:

1. The locally decidable frontier: Problems that can eventually be solved by applying the system's existing rules and concepts, given enough reasoning steps.
2. The structurally undecidable frontier: Problems and ambiguities that cannot be proved or refuted within the current regime at all, no matter how much compute is expended.

Local reasoning gradually resolves the first category and drives the system toward a stable local equilibrium, while leaving the second category completely untouched. In traditional symbolic AI, hitting this undecidable frontier caused the system to halt or crash. In modern language model and reinforcement learning pipelines, spending compute on a question that cannot be answered within the current representation is treated as wasted effort, suppressed by early stopping, timeouts, or reward penalties.

Our theory inverts this relationship. In an open-ended architecture, structural ambiguity is not an implementation defect to be eliminated; it is the primary computational resource of intelligence, because it generates what we call semantic surplus: the set of multiple, internally coherent candidate frameworks that become possible precisely when the current rules cannot dictate a single continuation.

How does a finite machine generate concrete new concepts from an unsolvable problem without an outside oracle telling it which questions are undecidable? Propositions 1 and 2 of our paper prove how this happens constructively through reflective trace reification:

• Because a real-world system does not know in advance whether an open problem is solvable in its current framework, it must invest compute in attempting a derivation.
• That attempt breaks the surface question down into a directed graph of intermediate subgoals and conditional dependencies — a reduction trace.
• When the problem is structurally undecidable in the current regime, the derivation stalls at a blocking frontier of unclosed intermediate steps. We prove that this blocking frontier is guaranteed to contain at least one intermediate premise that is itself undecidable in the current regime.
• At the object level, this stalled trace looks like a failed computation. When examined by a meta-level observer, however, the operational shape of the stalled search is translated into new conceptual content in a richer language. Resolving the intermediate blocking step in opposite directions constructs a branching pair of consistent successor frameworks that preserve validated prior knowledge while settling what the earlier framework could not.

Every time the system resolves a structural ambiguity by stepping into a more expressive regime, Gödelian incompleteness guarantees that the new regime will eventually generate a fresh undecidable frontier of its own. Local convergence is not global termination: the system achieves temporary stability within each regime while the sequence of regimes remains indefinitely extensible.

This mechanism exposes why a single monolithic model or an isolated self-improving algorithm hits a hard wall, shifting the engineering question from which model to which system.

First, consider why even the most rigorous single-agent self-modification scheme in computer science — Jürgen Schmidhuber's Gödel machine — cannot achieve open-ended self-extension on its own. A Gödel machine is allowed to rewrite any part of its software, including its own utility function, as soon as it finds a deductive proof from its initial axiom system that the rewrite improves expected utility. Because every modification requires deductive certification from the starting axioms, the Gödel machine can only act on the locally decidable region. If a genuinely transformative rewrite has value that is undecidable from the starting axioms, the Gödel machine must ignore it and discard the unclosed proof trace. All of its apparent meta-levels collapse back into the deductive span of its initial configuration.

Second, what happens when a system steps beyond deductive certification and turns open blocking frontiers into candidate extensions? Our Proposition 2 proves an unavoidable operational split. Because no finite computation can tell in advance whether an unclosed step on a blocking frontier is genuinely undecidable or merely not yet solved, generating candidate extensions across the frontier inevitably produces three kinds of branches at once:

1. Latent inconsistencies (assuming the opposite of a statement that was secretly provable in the old regime);
2. Conservative shortcuts (assuming something that already followed from the old rules); and
3. Genuine decisive extensions (consistent new frameworks that expand what the system can express).

In a classic single-context logic, a single inconsistent branch triggers logical explosion and ruins the system. Consequently, an open-ended system cannot be a single flat deduction engine. It requires what Gotthard Günther and Niklas Luhmann called polycontexturality: an architecture in which multiple distinct, locally coherent logical domains coexist in parallel without being prematurely forced into a single global true/false verdict, mediated by a distinct meta-level that tests, compares, and prunes inconsistent branches while preserving viable extensions.

Third, in Theorem 1 (The Fixed-Architecture Limitation), we use algorithmic information theory to establish a general limit for any isolated machine. If an open-ended system generates a history of conceptual regimes in which successive breakthroughs introduce genuinely new information over time, the information content of that history grows steadily with the number of transitions. By contrast, for any isolated architecture with a fixed finite state space, a fixed transition rule, and a fixed starting state, the entire history up to step $n$ can be described by the fixed program plus the step number $n$ — whose description length grows only logarithmically ($\log n$). Because steady linear growth inevitably outstrips a logarithmic bound, no fixed, isolated architecture can generate an open-ended conceptual history from its initial configuration alone.

How, then, can physically finite machines participate in open-ended intelligence? Merely wiring finitely many bounded agents together in a closed loop is not enough, because their combined state space is still a single finite closed system. What lifts the bound is the combination of three organizational mechanisms (Proposition 4 and Corollary 1):

1. Persistent External Memory with Semantic Coordinates: Because stepping into a new conceptual regime changes the meaning and scope of earlier terms, storing raw text chunks in a flat vector database (standard RAG) is insufficient; a statement retrieved without knowing the framework that produced it becomes ambiguous or misleading. External memory must store each insight paired with its semantic coordinates — which agent produced it, under which formal assumptions and goals, and from which reasoning trace it emerged.
2. Coupling Agents with Distinct Purposes: When two bounded agents operate under genuinely different relevance frames, the first agent admits signals from the environment that the second agent's current purpose actively filtered out as noise. When the first agent builds a new conceptual distinction from those signals and shares it through coordinate memory or translation channels, it injects genuinely new structure into the second agent's trajectory.
3. Preventing Consensus Monoculture: Conversely, if all agents share the exact same initial assumptions, training biases, and reward filters, their differences vanish and their collective capacity shrinks right back to that of a single isolated model. Productive collective intelligence requires a careful balance: enough shared language to translate and verify, and enough divergence in purpose and perspective to notice what no single agent could derive alone.

Open-ended intelligence is a property of a recursively organized cognitive process, not of an individual physical substrate.

Recognizing that no isolated, fixed-state model can generate an open-ended history and that intelligence resides in the organization of the system shifts the priorities for building and deploying AI:

1. From Brute-Force Scaling to Self-Extending Architectures: Pouring capital exclusively into pretraining larger monolithic models refines local interpolation within a fixed frame while leaving the system unable to revise its categories when that frame breaks. Durable capability comes from architectures that separate object-level execution from meta-level reflection, harvest stalled reasoning traces, isolate competing hypotheses across parallel contexts, and preserve provenance in memory.
2. Harvesting Productive Failure Instead of Hiding Ambiguity: Today's AI pipelines are built to hide or penalize failure: if a reasoning chain stalls or two agents disagree, the orchestrator truncates the branch or averages the outputs. In our architecture, when an agentic workflow stalls on a hard scientific, legal, or engineering problem, the unclosed reasoning graph is the most valuable asset the run produced — isolating the exact intermediate premises where the old framework needs to branch.
3. Replacing Flat Vector Retrieval with Coordinate Memory: Flat RAG stores text fragments stripped of the assumptions and goals under which they were generated. As an organization's models and objectives evolve, flat memories become silently misleading. Long-horizon reliability requires pairing every stored conclusion with its originating coordinates and logical relations.
4. Engineering Perspective Diversity Rather Than Homogeneous Swarms: Spinning up ten instances of the same model with slightly tweaked role prompts does not create collective intelligence. Genuine multi-agent gains require coupling perspectives that select different aspects of the problem and confronting their disagreements explicitly.

• Read Note #08: Small Models Think Better When They Reflect Polycontexturally
• Read Note #07: Separating Intelligence and Authority in Agentic Systems