§ The Biomimetic Architecture of Software 4.0

Specification Status: Draft (converted from arXiv preprint)

Source

https://arxiv.org/abs/2606.04025

Authors:

• Philip Sheldrake, Unnamed Labs (Amsterdam)
• Dirk Scheffler, Unnamed Labs (Karlsruhe)

Participate:

Local Spec-Up-T project

§ Abstract

Dominant programming paradigms inherit an execution model optimised for a bygone era of a single human mind instructing a local machine, leaving contemporary systems burdened with historical path dependencies. When forced to host multi-dimensional, connectionist intelligence, this brittle assembly model fractures under the weight of a profound probabilistic-symbolic impedance mismatch. While contemporary Software 3.x frameworks attempt to patch the mismatch by encasing large language models (LLMs) in increasingly complicated external harnesses, this spiralling architectural complexity only compounds the carrying cost of static code assembly. To address the cause rather than the effects, this paper introduces Software 4.0 — an autopoietic heterarchy of human intelligence, neural AI, and natively reflective symbolic substrate. Under this paradigm, software is transformed from an inert corpus to be parsed into a self-regulating metabolic network that natively verifies, modifies, and evolves its own structural integrity. We present Recognitive, the programming language and platform that materialises this architecture. By offloading the burden of structural verification to a deterministic substrate, it unlocks a superior inference-time scaling regime — one where connectionist compute translates entirely into deep semantic exploration and hypothesis traversal rather than the ruinous computational and financial cost of simulating structural constraints probabilistically. Moving beyond the legacy ‘Software Factory’ mindset, we outline the theoretical foundations required to ground connectionist intent and arrive fully in the intelligence age. This is a foundational vision paper; empirical evaluation and formal specification of the type system and operational semantics are the subject of future work.

§ Terms and Definitions

For the purposes of this document, the following terms and definitions apply. Terms are derived from The Biomimetic Architecture of Software 4.0 (arXiv:2606.04025v1).

allostasis (allostatic, allostasis)

Purposive self-regulation in which a system predicts and pre-adjusts set points to maintain internal stability while pursuing adaptive goals.

autopoiesis (autopoietic, Autopoiesis, Autopoietic, autopoiesis)

Self-producing structural identity and closure; the foundational precondition for the biomimetic axes of Software 4.0, providing the bounded operational perimeter without which allostatic regulation, active inference, and immunological memory cannot execute.

computational reflection (Computational reflection, computational-reflection)

The capacity of a system to evaluate and manipulate its own internal state recursively.

computational ribosome (computational-ribosome)

An organic code layer that projects the live, exo-homoiconic state — active types, properties, constraints, and dependency graphs — directly into a model’s context.

constitutive coupling (constitutively coupled, Constitutive coupling, constitutive-coupling)

A relational architecture in which distinct roles are so operationally interdependent that none can function in isolation; every functional role is produced and maintained by the internalised causal loops of the system itself.

context engineering (Context engineering, context-engineering)

The systematic priming of a model’s working memory with curated repository metadata and static schemas prior to generation, characteristic of Software 3.2.

endo-homoiconicity (Endo-homoiconicity, endo-homoiconic, endo-homoiconicity)

A deepening of classical homoiconicity that establishes a strict structural isomorphism across the full representational substrate — unifying types, invariants, and execution paths into a canonical form through which data, configurations, function calls, errors, and behavioural contracts are natively composed, evaluated, and resolved.

endo-intelligence (Endo-intelligence, endo-intelligence)

The bounded intelligence of internal data and code organisation, contrasted with exo-intelligence.

epistemic late binding (Epistemic late binding, epistemic-late-binding)

The structural deferral of semantic resolution: the substrate’s grammar outlines an invariant architectural envelope that remains semantically plastic until interaction with a reasoning agent, while preserving strict structural invariance throughout execution.

exo-homoiconicity (Exo-homoiconicity, exo-homoiconic, exo-homoiconicity)

An operational state where types and properties natively declare their own potentiality and structural affordances, rendering the system’s internal symbolic topology innately transparent to external intelligences. It is the essential means to exo-intelligence.

exo-intelligence (Exo-intelligence, exo-intelligence)

The capacity to seamlessly externalise and internalise knowledge; a substrate-level capacity that enables domain-agnostic intelligibility across heterogeneous intelligence modalities without an intermediate translation layer.

heterarchy (heterarchically, Heterarchy, heterarchy)

A non-hierarchical organisational form in which human intelligence, neural AI, and the symbolic substrate operate as co-constitutive functional differentiations within a single closed-loop system.

homeostasis (homeostatic, homeostasis)

Feedback-driven regulation that maintains systemic coherence under perturbation; in Software 4.0, realised as structural self-regulation within supersoftware.

Homoiconic Meta-Mapping (HoMM, homoiconic-meta-mapping)

A connectionist framework that maps basic tasks and higher-order task transformations into a single shared representational space, improving zero-shot cognitive flexibility.

judgement (systemic judgement, Judgement, judgement)

Architectural accountability to the system’s own structural reality: neural intent and symbolic verification are constitutively coupled, forcing probabilistic reckonings into reconciliation with the formal truth of the symbolic substrate.

knowledge representation and reasoning

A tradition of explicit structured representation (often abbreviated KR&R); in Recognitive, operated constitutively and reactively as the execution substrate rather than as a passive external abstraction layer.

large language model (large language models, LLM, LLMs, large-language-model)

A probabilistic connectionist model used for generation and inference; in Software 4.0 it is constitutively coupled to supersoftware rather than orchestrated solely through an external harness.

Model Context Protocol (MCP, model-context-protocol)

A Software 3.x protocol that standardises contextual transport and API schemas for model–tool communication at the interface boundary, without constraining internal execution semantics of tools.

narrow waist (Narrow Waist, narrow-waist)

A minimal, universal interface that allows diverse higher-level applications to run on diverse lower-level infrastructures. In Recognitive, the waist is established at the active representational layer to preserve architectural intent, not merely execution logic.

Panlingual Exchange Format (PEF, panlingual-exchange-format)

Within the Recognitive architecture, the foundational substrate for structural serialisation and representation, encoding the system’s structural affordances directly into the communication layer and unifying functional logic, persistence, reflection, schema metadata, presentation, configuration, and runtime error handling.

probabilistic-symbolic impedance mismatch (probabilistic-symbolic-impedance-mismatch)

The paradigmatic friction between connectionist intelligences and traditional symbolic software architectures across determinism, state management, type safety, cost/latency, and debugging.

programmable harness (external harness, external harnesses, programmable-harness)

An elaborate exogenous programmatic architecture that encases a connectionist core to orchestrate multi-agent generation, review, and execution; remains fundamentally decoupled from the internal state-space it observes.

reckoning (reckoning)

Symbolic manipulation decoupled from existential consequence, in which the system lacks any mechanism to be genuinely beholden to its representations; contrasted with judgement.

Recognitive (recognitive)

The programming language and platform that materialises the Software 4.0 architecture by embedding a reflective symbolic substrate that binds probabilistic intent to deterministic invariants.

requisite variety (Law of Requisite Variety, Ashby's Law of Requisite Variety)

The cybernetic principle that a regulator maintains control only to the degree that its internal variety matches or exceeds the variety of the system it regulates.

semantic void (Semantic Void, semantic-void)

The structural blind spot in which an LLM interfaces with fragmented static artefacts and dead text strings, forced to probabilistically simulate an execution context it cannot natively see.

Software 1.0 (software-1.0)

The classical paradigm of human-authored, deterministic source code.

Software 2.0 (software-2.0)

The paradigm hypothesis that connectionist weights would completely supplant explicit procedural logic.

Software 3.0 (Software 3.x, software-3.0)

A hybrid configuration in which deterministic code generation is systematically delegated to probabilistic language models; includes the Software 3.0–3.2 continuum of episodic co-authorship, agentic loops, and compiled agentic engineering.

Software 3.1 (software-3.1)

An agentic iteration of Software 3.x that introduces closed-loop execution feedback, programmatically coupling language models with local testing environments.

Software 3.2 (software-3.2)

The contemporary state of Software 3.x that scales agentic dynamics through context engineering and multi-agent pipelines governed by a programmable harness.

Software 4.0 (software-4.0)

An autopoietic heterarchy of human intelligence, neural AI, and a natively reflective symbolic substrate. Under this paradigm, software is transformed from an inert corpus to be parsed into a self-regulating metabolic network that natively verifies, modifies, and evolves its own structural integrity.

strange loop (Strange Loop, strange-loop)

A computational synthesis of mathematical self-reflection and biological expression; in Software 4.0, the structural form of intelligence realised as an autopoietic heterarchy.

supersoftware (Supersoftware, supersoftware)

The reflective, formally verifiable symbolic substrate that is the canonical embodiment of the strange loop; it closes the semantic void and provides deterministic ground truth for systemic judgement.

vibe coding (Vibe coding, vibe-coding)

A Software 3.0 practice in which developers rely heavily on generated code without fully understanding its implementation, leaving correctness to post hoc human verification.

§ 1 Introduction: Exo-intelligence

Most dominant programming paradigms in widespread use today were conceived and substantially developed before the advent of the World Wide Web, let alone large language models (LLMs). The paradigms — ranging from early assembly to contemporary memory-safe languages — share a siloed execution model designed for a single human mind to instruct a local machine.

While non-human co-authorship is currently practised within these paradigms (as seen in the current Software 3.x eras, see Table 1), the interaction is fundamentally brittle. For example: vulnerability to severe performance degradation under minor prompt perturbations [52], behavioural failure cascades in autonomous agent trajectories [35], and persistent decoupling between surface-level text fluency and actual functional correctness [25].

These legacy paradigms lack what we call endo- and exo-homoiconicity. Endo-homoiconicity fundamentally deepens the classical homoiconic properties found in languages such as Lisp. Rather than merely equating source text with data structures, it establishes a strict structural isomorphism across the full representational substrate — unifying types, invariants, and execution paths into a canonical form through which data, configurations, function calls, errors, and behavioural contracts are natively composed, evaluated, and resolved.

Expanding outward, exo-homoiconicity unifies communication and reflection. It is an operational state where types and properties natively declare their own potentiality and structural affordances, rendering the system’s internal symbolic topology innately transparent to external intelligences. It transforms interoperability from an exercise in explicit translation to an act of native structural intelligibility.

Exo-homoiconicity is the essential means to a critical end: exo-intelligence, which we define as the capacity to seamlessly externalise and internalise knowledge. Whereas endo-intelligence represents the bounded intelligence of internal data and code organisation, exo-intelligence is a substrate-level capacity that enables domain-agnostic intelligibility across heterogeneous intelligence modalities without an intermediate translation layer.

Exo-intelligence is distinct from classical semantic interoperability, ontology sharing (e.g., OWL), and linked data paradigms. Where legacy semantic frameworks rely on static, schema-bound taxonomies requiring a priori alignment to resolve meaning, an exo-intelligent system derives its intelligibility directly from its endo- and exo-homoiconic architecture.

We learn from mathematical self-reflection and biological expression, culminating in a novel computational synthesis: the strange loop [29]. We introduce supersoftware as the canonical embodiment.

§ 2 The Evolution of Software Paradigms: The Strange Loop

Retrospectively, the classical paradigm of human-authored, deterministic source code defines Software 1.0. The rapid maturation of deep neural networks subsequently prompted a temporary theoretical bifurcation: the hypothesis that connectionist weights would completely supplant explicit procedural logic, a paradigm termed Software 2.0 [37]. Rather than total displacement, however, the evolutionary trajectory instead yielded a hybrid configuration: the systematic delegation of deterministic code generation to probabilistic language models, dubbed Software 3.0 [38]. Within the 3.x continuum, we identify a rapid architectural progression through three distinct eras (see Table 1).

The baseline Software 3.0 can be understood as episodic, decoupled co-authorship, in which the model functions primarily as an unstructured autocomplete substrate. The developer prompts for discrete procedural blocks and evaluates the resulting outputs largely through local inspection and testing rather than through integrated reasoning or formal guarantees. At its extreme, where developers rely heavily on generated code without fully understanding its implementation, this practice has become known as vibe coding. In such workflows, responsibility for establishing correctness remains primarily with the human developer through post hoc verification.

Recognising that unconstrained token generation is inherently fragile, Software 3.1 introduced closed-loop execution feedback. In this agentic iteration, language models are programmatically coupled with local testing environments. Upon generating a candidate code block, the substrate evaluates the program automatically; runtime failures or compiler exceptions generate explicit error streams that are piped directly back into the model’s context window. This automates a reactive, iterative self-correction loop, though it remains strictly bounded by the superficial semantic bandwidth of the error logs themselves.

The contemporary state of the art, Software 3.2, attempts to scale these dynamics to complex macro-level software architectures through sophisticated meta-frameworks. As extensive codebases exceed the processing limits of singular model context windows, the connectionist core must be encased within an elaborate programmatic architecture. This era relies on two primary mitigations: first, intensive context engineering [47], which systematically primes the model’s working memory with curated repository metadata and static schemas prior to generation; and second, the construction of multi-agent pipelines governed by a programmable harness [39]. Here, heterogeneous models engage in a multi-stage, iterative relay — alternately generating, reviewing, and isolating code execution paths until the framework forces a compiled output. Notably, while this harness may incorporate static analysis or bounded model checking, full formal verification remains exceptional; most 3.2 systems rely on empirical execution feedback rather than semantic proofs of correctness.

Table 1: Comparative taxonomy of software paradigms

The structural fragility of this ungrounded paradigm reduces the engineering discipline to a form of techno-magical thinking — resembling historical descriptions of apprentices uttering hopeful incantations to medicine jars [19, 16]. A stark manifestation of this occurred in early 2026 with the release of Claude Code, a state-of-the-art agentic development tool with runtime execution capabilities [61]. Despite comprising a massive, 519,000+ line TypeScript architecture, its operational loops rely heavily on a probabilistic foundation rather than a deterministic one [61]. Lacking a native symbolic substrate to enforce structural invariants, its creators were reduced to embedding natural language prompts within the system itself, explicitly pleading with the model to “report outcomes faithfully”, “never characterize incomplete or broken work as done”, and “be careful not to introduce security vulnerabilities” [6].

Software 4.0 emerges as the direct architectural resolution to this impasse, defined here as the autopoietic [46] heterarchy of human intelligence, neural AI, and reflective, formally verifiable symbolic substrate. The substrate — which we call supersoftware in our embodiment — closes the semantic void (see Section 3) and provides the deterministic ground truth and verifiable integrity to transition from neural “reckoning” to systemic “judgement” [58] (see Section 9). The structural form of intelligence is no longer an external controller (the harness) but the heterarchy. It moves us from mechanistic assembly toward an ecology of self-referential differentiation.

§ 3 The Semantic Void: The Limits of Software 3.x

Our use of semantic here refers to the operational semantics: the strict, formal invariants, execution pathways, and state dependencies natively enforced by the symbolic substrate itself.

Current agentic workflows operate within a structural blind spot. Even when confronting modern, well-factored code bases designed for automated consumption, an LLM interfaces with a fragmented landscape of static file artefacts, frozen dependencies, and passive documentation. As traditional codebases exist as dead text strings until batch compilation or temporal evaluation, an external model must compensate probabilistically for an execution context it cannot natively see.

Crucially, this blind spot cannot be bypassed by merely exposing or training models on compiler Intermediate Representations (IR), such as Meta’s LLM Compiler [13]. This model still requires a rigid, external software harness to prevent it from hallucinating invalid states, even after feeding a transformer 546 billion tokens of pure compiler IR and assembly. Because an IR remains a static serialisation of code syntax, an external model is still forced to probabilistically simulate an execution trace over inert artefacts. No amount of inference on traditional software code or IR can reconstruct what was never made explicit. LLMs are, in effect, generating text into a void.

This structural decoupling does not merely create engineering debt; it also introduces significant socio-technical friction. As non-human co-authorship scales through external interfaces, the human role shifts from creative design to rapid, reactive verification — a phenomenon sometimes referred to as pull request fatigue. A cognitive misalignment leaves developers trapped in an unsustainable cycle of monitoring automated intent [12]. Software development is rendered fundamentally chaotic as long-horizon agentic trajectories decay into unpredictable behavioural failure loops [33].

Such structures expose a profound probabilistic-symbolic impedance mismatch between traditional software architectures and connectionist intelligences. Where legacy computing environments expect two deterministic, precise systems to interface cleanly, the integration of an LLM introduces fundamental paradigmatic frictions: determinism (fuzzy token vectors vs. invariant compiler correctness), state management (stateless, sliding context windows vs. rigid runtimes), type safety (probabilistic token streams vs. static structural boundaries), cost and latency (expensive matrix multiplication vs. O(1) algorithmic checks), and debugging (non-deterministic hallucinations vs. deterministic execution traces).

Where Software 3.x attempts to patch the impedance mismatch by wrapping the system in increasingly complicated external harnesses, Software 4.0 collapses the boundary. It embeds a reflective substrate that binds probabilistic intent to deterministic invariants natively at the exact point of generation. Recognitive introduces a qualitative shift toward epistemic late binding. We define this as the structural deferral of semantic resolution itself — rather than pre-determining rigid procedural paths, the substrate’s grammar outlines an invariant architectural envelope that remains semantically plastic until interaction occurs with any reasoning agent. This allows concrete execution pathways to be instantiated dynamically through interactions that the envelope natively grounds, renders coherent, and formally verifies, preserving strict structural invariance throughout execution.

§ 4 Foundational Mechanics: Parsimony and Reflection

We inherit Ada Lovelace’s insight that symbolic enumeration grants a machine domain-agnostic universality [27], a concept then formalised mathematically by Gödelian numbering, which demonstrates that formal syntax, proofs, and computations can be cleanly mapped as invariant structural primitives within a single numeric space [59].

Software 4.0 couples such structural parsimony with computational reflection — the capacity of a system to evaluate and manipulate its own internal state recursively [57]. By executing these reflective, homoiconic dynamics within a radically reduced type landscape, the platform directly honours the core ethos of the RISC heritage — stripping away arbitrary syntactic abstraction layers to yield optimal execution performance and systemic resilience [50]. This cross-stack mathematical and structural parsimony acts as the primary defence against structural entropy.

§ 5 Foundational Cybernetics: Model Drift and Variety

Cybernetics bridges engineered, artificial systems, and evolved, natural systems such as organisms and societies [26]. It “approaches systems in terms of purpose — the purpose attributed to the system by observers observing ‘the system’ as well as our own purpose as observers in explaining ‘the system’.” [49]

At the core of this synthesis is the requirement of endogenous control to maintain systemic coherence, i.e. the direct, active compensation of environmental perturbations must be embedded natively within a system’s internal operational dynamics to prevent structural decay. In our contexts, while an external harness can execute high-frequency feedback loops to enforce operational boundaries, it remains exogenous and so fundamentally decoupled from the internal state-space of the system it observes. As the controller merely runs a lagged model about the system rather than having regulatory logic distributed with and within the substrate, its representation inevitably falls out of step with the live, probabilistic state-space it intends to regulate — a semantic fracture.

This vulnerability is compounded because a system doesn’t just fall into drift through exogenous isolation, but also through insufficient regulatory variety. Satisfying Ashby's Law of Requisite Variety requires that a regulator maintains control only to the degree that its internal variety matches or exceeds the system’s variety [7]. Whereas an external harness has access only to a system’s observable outputs and a limited set of interventions, structurally bounding its variety by the narrower bandwidth of the orchestrator-substrate interface, a self-regulating system has direct, unmediated access to its own internal states. Its regulatory variety is thus structurally unbounded by an external boundary layer.

It follows that externalised harness architecture can never achieve the regulatory capacity of a constitutively self-modelling substrate, regardless of sophistication.

When a system entails a direct, endogenous control mechanism, it achieves a radical reflexivity concerning its own operations — the capacity to observe and describe itself as part of the system it regulates [63]. This reflexive closure, central to second-order cybernetics, enables a far more complex capacity for systemic sense-making — how an autonomous organism appreciates a subset of its environmental couplings as meaningful [62] — and, by extension, provides the structural foundation for shared, intersubjective meaning-making across the human-machine boundary [15].

As external harnesses are innately incapable, we turn to see how nature does it.

§ 6 Foundational Biological Principles: Constitutive Coupling

Computer science repeatedly rediscovers or mimics mechanisms long realised in biological systems, suggesting not occasional analogy but structural convergence driven by shared constraints on information processing under noise, decentralisation, and limited resources.

This is evident in neural computation models of memory and learning, from Hopfield networks [31] to backpropagation in distributed connectionist systems [56] — the latter being functionally analogous to biological credit assignment even if mechanistically distinct. It is equally explicit in evolutionary search paradigms such as genetic algorithms [30], and in distributed coordination, swarm and collective intelligence methods, ranging from flocking models [53] to ant colony optimisation [17]. Even foundational network protocols such as TCP congestion control [34] embody homeostasis feedback principles closely analogous to biological regulation under resource constraints. Taken together, these results reinforce the perspective that modern computation does not merely draw inspiration from biology, but repeatedly converges upon its functional strategies when confronted with equivalent systemic constraints.

Biological systems demonstrate that resilient configurations persist (survive selection pressures for billions of years) through constitutive coupling: where distinct roles are so operationally interdependent that none can function in isolation [40, 64, 41]. This relational architecture reflects Rosen’s formalisation of organisms as being ‘closed to efficient causation’ — a state where every functional role is produced and maintained by the internalised causal loops of the system itself [55].

Software 3.x produces an unstable monoculture of ungrounded modality, leaving the system without a constitutively coupled structural anchor. Recognitive resolves this ecological crisis by establishing an exo-homoiconic substrate that functions as the required organic code, bounding probabilistic neural reasoning within verifiable symbolic invariants.

We are guided by four generative axes:

§ 6.1 Axis 1: Encoding and Expression

The distinction between information storage and functional execution, exemplified by DNA and protein systems, is associated with biological processes that maintain stability while remaining highly responsive to context. It’s a pattern preserved across diverse lineages through conditionally permissive, structurally constrained coupling [46, 2, 51].

Recognitive takes the encoding role, consciously replacing opaque encapsulation with transparent reflection and expert late binding (model definitions separated from the functions and algorithms that bind to them at runtime). Supersoftware is the expression, with model definitions interpreted in the moment, in context.

§ 6.2 Axis 2: Novel Exploration and Low-Variance Execution

The distinction between flexible, generative computation and low-variance predictive execution, exemplified by the cortical and cerebellar systems, enables neural processes to explore novel strategies while maintaining reliable performance through collaborative and corrective coupling. The cerebellum’s forward models bias cortical proposals [66].

In the contexts here, the LLM generates fluid stochastic creativity and probabilistic inference, expressively bounded by supersoftware’s structural demands. Conversely, supersoftware guarantees repeatable, formally verifiable execution, anchoring the LLM’s generative volatility. The coupling is collaborative and corrective: the model operates within an uncompromising reality where its proposals are immediately forced into structural reconciliation.

§ 6.3 Axis 3: Intent and Self-Regulation

The distinction between intentional, goal-directed behaviour and involuntary, anticipatory selfregulation, exemplified by somatic and autonomic nervous systems, enables organisms to pursue adaptive goals while maintaining internal stability through allostatic, purposive coupling (where the autonomic system predicts and pre-adjusts set points) [60].

In our contexts, human intelligences provide the authoritative intent, directing without authoring at the supersoftware substrate level. Contextual interfaces are used to establish governing structural invariants directly (for example, see [20]), and LLMs serve as conductive operational pathways rather than detached intermediaries, interpreting human direction to generate fluid, operational sub-intents that remain structurally bounded by the substrate.

LLMs also participate in the self-regulation loop. They make proposals, receive structural feedback, and iterate, collaborating with supersoftware toward coherence without needing human intervention at every step. The supersoftware embodies structural self-regulation, self-verification, self-correcting execution. It grounds and verifies LLM proposals, coupled to human intent through purpose rather than instruction.

§ 6.4 Axis 4: Diverse Generation and Selective Retention

The distinction between combinatorially diverse generation and selective, affinity-based retention, exemplified by the immune repertoire’s diversity and selection for stronger antibody binding, enables the system to respond to novel threats and not attack itself [11]. In other words, retention emerges only from successful discrimination, and discrimination is sharpened by immunological memory.

In our contexts, human and LLM intelligences generate diverse proposals (code, structures, natural language translations), and supersoftware provides the formally verifiable structural identity (a sense of ‘self’). It discriminates valid from invalid, and retains successful patterns as ‘verified memory’ instantiated as a distributed registry of structural invariants and successful homeostatic adaptations accumulated across network deployments.

§ 6.5 Self Models

Such constitutively coupled functional differentiations encompass the system’s ability to maintain a model of itself without a central architect — to encode, inspect, and act on its own structure [54]. For our four axes, the underlying dynamics are modelled in terms of autopoiesis, encephalic active inference, allostasis, and immunological memory. Crucially, while these four distinct regimes operate heterarchically, autopoiesis acts as our primary ontological guide across this thesis and taxonomy. This asymmetry is intentional and biomimetically rigorous: autopoietic closure is the foundational precondition for the remaining three axes, providing the bounded, self-producing structural identity — the system’s operational perimeter — without which it cannot execute allostatic regulation, engage in predictive active inference, or leverage immunological memory.

§ 7 Synthesis: The Architecture of Software 4.0

§ 7.1 Coupling LLMs and Supersoftware

Recent work in code language modelling suggests that programming languages with highly explicit and regular structural representations should, in principle, align well with the inductive biases of transformer architectures. Studies on AST/CST-aware learning have repeatedly shown that models benefit when syntactic structure is made explicit rather than inferred indirectly from surface token streams [1]. Likewise, syntax-aware training strategies show that incorporating structural information materially improves code understanding and generation [23]. Homoiconic languages are notable in this context because their surface syntax already approximates a serialised abstract syntax tree, meaning the distance between program text and program structure is uniquely compressed.

This optimisation is strongly validated by connectionist research into meta-learning. Lampinen and McClelland (2020) demonstrated that when a neural architecture exploits a deep functional analogy between basic tasks and higher-order task transformations — mapping both into a single, shared representational space via a Homoiconic Meta-Mapping (HoMM) framework — it achieves remarkable cognitive flexibility [43]. By unifying mapping within this homoiconic space, the network frequently reaches 80% to 90% performance on novel, zero-shot task adaptations, significantly outperforming alternative connectionist baselines where task context is merely appended as an external input to a standard feed-forward network. Software 4.0 satisfies this structural constraint natively. By replacing text-mediated interfaces with a unified, reflective topology where code, state, and domain context share an identical structural presentation, the model develops a deep structural grasp of underlying logic, radically improving out-of-distribution generalisation and correctness.

Crucially, contemporary connectionist systems demonstrate a profound architectural fragility in practice. Structural perturbation studies confirm that transformer models are disproportionately sensitive to syntactic and compositional irregularities; disrupting structural coherence or introducing minor surface-level prompt perturbations impairs model reasoning far more severely than semantic alterations [65, 52]. This vulnerability exposes a fundamental microarchitectural reliance on tokenlevel dependency mappings to preserve operational semantic representations.

To mitigate this dependency, structural parsimony and homoiconic representations become an architectural necessity rather than a stylistic preference. By minimising parser ambiguity, eliminating heterogeneous syntactic forms, and avoiding operator precedence irregularities, such representations drastically reduce syntactic entropy. In combination with an unambiguous grammar design, this structural regularity minimises the cognitive overhead of the text layer, offering an optimal target for both pattern learnability and downstream synthesis fidelity.

Empirical evidence confirms that code-centric reasoning trajectories yield significantly higher performance than natural language alone, validating the thesis that connectionist systems optimise when navigating strict structural environments rather than unstructured text [32]. Software 4.0 takes this insight to its logical conclusion. Rather than just using code-centric representations as an optimised bridge, the neural-symbolic gap is collapsed into a natively self-modelling substrate. By codifying the world model into the substrate itself, the architecture shifts from estimating structure probabilistically to reasoning as a structural invariant.

Admittedly, current baseline datasets do not yet provide direct empirical isolation of these homoiconic advantages over conventional languages such as Python or Java. Because existing coding benchmarks overwhelmingly under-represent homoiconic ecosystems, controlled comparisons remain difficult, and corpus-scale effects presently dominate observed language-specific performance differences. However, this empirical deficit vanishes if one adopts target-driven training strategies designed to mitigate dependence on massive naturally occurring corpora — for example, through structure-aware pre-training, synthetic curriculum generation, or explicit AST-level supervision. Critically, because a homoiconic substrate minimises syntactic entropy by design, these structure-centric methods can be executed at a fraction of the computational and financial cost required by conventional, highentropy languages. Under these specialised, low-overhead regimes, the intrinsic sample efficiency and theoretical advantages of homoiconic representations become considerably more salient.

Crucially, this neurosymbolic coupling redefines the scaling frontier that ungrounded neural progression cannot cross. As connectionist models lean heavily into inference-time scaling regimes, attempting to maintain structural coherence purely within probabilistic search trajectories imposes an unsustainable computational and financial penalty. In ungrounded architectures, the model must expend a massive portion of its search budget and autoregressive token overhead simply to probabilistically simulate structural constraints, track state boundaries, and enforce type safety rules. By contrast, shifting these invariants to a reflective, symbolic substrate offloads the entire burden of structural verification to a deterministic engine. As the substrate enforces boundaries absolutely, the neural search space is freed from the overhead of probabilistic self-verification. Consequently, the Software 4.0 paradigm unlocks a qualitatively superior inference-time scaling regime — one where compute translates entirely into semantic exploration and deep hypothesis traversal rather than superficial structural simulation.

To guarantee this structural transparency, Recognitive operates fundamentally as a constitutive knowledge representation and reasoning (KR&R) system [10] paired with logic-programming-style formal verification [42]. While it inherits the KR&R tradition’s commitment to explicit structured representation and the logic programming tradition’s commitment to formal verifiability, it departs radically from both by operating in a reactive rather than batch mode, embedded directly as the execution substrate rather than applied as an external abstraction layer. Traditional knowledge representation and reasoning models are descriptive — they build passive, abstract models of things external to the software. In Software 4.0, the world model is constitutive; it is the software itself.

This architecture functions essentially as a computational ribosome [8] — an organic code layer that projects the live, exo-homoiconic state (comprising active types, properties, constraints, and dependency graphs) directly into the model’s context. Rather than parsing dead text strings to infer system state, the LLM directly enacts a live, self-describing digital organism whose structural invariants are checked natively and in real time.

While humans may no longer author this substrate directly — engaging instead through natural language and contextual interfaces — the supersoftware remains conceptually legible. It provides the ground truth that allows the neurosymbolic AI to explain itself, humans to verify it, and the system to maintain its own structural integrity and identity.

§ 7.2 The ‘Narrow Waist’ of Architectural Intent

In systems architecture, a narrow waist refers to a minimal, universal interface that allows diverse higher-level applications to run on diverse lower-level infrastructures. In traditional compiler design (e.g. LLVM), an intermediate representation (IR) acts as the narrow waist between many front-end languages (e.g. C++, Rust, Swift) and various back-end architectures (e.g. x86, ARM, RISC-V), preserving operational semantics while abstracting implementation details.

The LLM industry’s current proxy for a narrow waist — Model Context Protocol (MCP) — standardises contextual transport and API schemas beautifully [5]. It addresses interoperability in Software 3.x by defining a uniform protocol for model-tool communication. It standardises how models request and receive context or tool execution results via structured message exchanges; the external wire transmission of stateless context. However, it does not define or constrain the internal execution semantics of tools, which remain opaque to the protocol. MCP governs interaction at the interface boundary, not runtime behaviour within tool implementations.

Recognitive moves the waist higher by one full level of abstraction from the IR, establishing it directly at the active representational layer to preserve architectural logic, not just execution logic. This isn’t just operational semantics, but meaning in its formal sense: the purposes and constraints that define the system. When an LLM writes Java and it is compiled to an intermediate representation, this meaning is lost twice. When an LLM co-authors supersoftware, the meaning is codified natively. Where MCP uses schemas to standardise how models invoke tools and receive structured results, Recognitive embeds the living operational invariants, types, and logic dependencies directly into the computational environment, ensuring that the LLM navigates an uncompromising symbolic reality rather than an ungrounded API interface.

Akin to the ribosome, exo-homoiconicity affords a far greater application of domain-agnostic algorithms. Guided purely by declared schema without semantic awareness, they can traverse, validate, transform, merge, patch, serialise, replay, or persist any data form, analyse relationships, track causality, and preserve referential integrity.

Within the Recognitive architecture, this capability is realised through the Panlingual Exchange Format (PEF) — the foundational substrate for structural serialisation and representation, encoding the system’s structural affordances directly into the communication layer. Designed to store and transport type-safe context referentially, comparably, and polymorphically, PEF enables deep nested and highly streamable data structures to cross system boundaries without structural degradation. Its scope extends beyond wire transmission: PEF unifies functional logic, persistence, reflection, schema metadata, presentation layers, configuration states, and runtime error handling into a single cohesive medium. Consequently, it acts as the common representational plane through which connectionist systems can safely read, mutate, and reason over complex symbolic architectures without intermediate compilation.

§ 8 Distinction from Classical Reflection and Mirror Models

Exo-homoiconicity is a structural property where types and properties declare their own operational affordances. It turns reflection from a passive mirror into an active instrument of computation, cognition, and intelligence. Through this architecture, automated systems can perceive and manipulate system state contextually and meaningfully — establishing the structural prerequisite for exo-intelligence. Serialisation becomes intrinsic, transmission decouples entirely from implementation boundaries, and versioning, patching, and replaying become purely structural operations.

Exo-homoiconicity represents a topological inversion of the classical reflective architectures proposed by Smith [57] and Maes [44]. While the ‘reflective tower’ of 3-Lisp was designed to enable internal metacircularity — where a system’s internal state is made explicit to its own interpreter for autonomous self-modification — exo-homoiconicity externalises this reflective interface. It ensures that the system’s ability to ‘see itself’ and adjust its execution trace is simultaneously projected outward, self-declaring its potentiality to external intelligences. Traditional structural reflection often leaves a semantic void where the purpose of a code block remains implicit and context-dependent — an exo-homoiconic substrate, by contrast, guarantees that types and properties declare their own functional capabilities. This allows external intelligences to reason about architectural intent and form without requiring exhaustive pre-trained domain knowledge or brittle procedural parsing.

This approach further departs from the stratified ‘mirror models’ described by Bracha and Ungar [9]. While mirrors decouple metadata to preserve system cleanliness for the human developer, they treat reflection as an optional tool for offline inspection. In Software 4.0, exo-homoiconicity is a constitutive requirement of the substrate rather than a stratified window into a static corpus. It changes the structural form of intelligence from a private, internalised execution loop to a shared, canonical environment, effectively transforming the software from a corpus to be parsed into a coupled substrate to be continuously enacted. This transition is essential for overcoming the semantic latency inherent in externalised harness models, replacing the puppet-like manipulation of traditional code with the autopoietic regulation of a coherent computational organism.

§ 9 On judgement

To satisfy the formal distinction of judgement from reckoning, we explicate the mechanism of systemic judgement as an architectural accountability to the system’s own structural reality [58]. Traditional architectures remain confined to reckoning because their symbolic manipulations are completely decoupled from existential consequence; the system lacks any mechanism to be genuinely beholden to its representations.

Software 4.0 bridges this semantic divide by operationalising the world model through the autopoietic strange loop. Within this architecture, the world model is not a passive, arbitrary data file to be parsed from the outside, but an active metabolic network of homeostatic boundaries, environmental dependencies, and operational constraints. Because the substrate is exo-homoiconic, its structural potentiality and non-negotiable boundaries are directly perceptible to the neural model. When the neural agent proposes an action, its probabilistic reckonings are structurally forced into reconciliation with the formal truth of the symbolic substrate.

Systemic judgement is achieved precisely because the strange loop realises neural intent and symbolic verification as constitutively coupled functional differentiations, sustaining the system’s formal and operational integrity. It is this structural necessity — the systemic requirement to confront the consequences of every action against its own constitutional integrity — that elevates Software 4.0 from rules-based calculation to genuine operational-semantic engagement with its world.

§ 10 Bootstrapping

Definitionally, connectionist-symbolic coupling must be native to Recognitive’s architecture from day one. Every interaction injects the live world model — the system’s current structural state, its declared constraints, and its dependency graph — directly into the LLM’s context window. As the substrate self-declares its own structural rules, a highly capable model can reason over and mutate Recognitive code zero-shot; the system itself provides the dense structural context that makes valid generation possible without requiring a massive, pre-existing training corpus. As generated code is evaluated deterministically against the integral world model prior to execution, incorrect generations are intercepted algorithmically. This turns the runtime into a continuous, real-time alignment loop, where every structural rejection generates a high-fidelity training signal.

This regularised feedback operationalises the alternative training strategies anticipated in section 7.1, radically redefining the pre-training paradigm. While traditional programming languages require sequence models to expend vast parameter capacity simply learning to approximate irregular surface syntax, Recognitive bypasses this tax. Endo-homoiconicity enables the model to focus cleanly on programmatic intent rather than superficial syntactic correctness [14] — and simultaneously, the exo-homoiconicity offers a more expansive, self-referential topology, establishing a significantly denser and more interconnected web of structural patterns within the model’s latent vector space. Taken together, Recognitive’s grammar specification, type system, and core codebase constitute a high-fidelity structural seed — one that is vastly richer in semantic signal than an equivalent corpus of unstructured legacy code. Consequently, these structure-centric optimisation strategies do not need to teach the model how to avoid syntax errors; instead, they convert basic in-context comprehension into native cognitive fluency, rapidly accelerating the strange loop’s efficacy.

Importantly, the adoption of Software 4.0 does not demand a monolithic re-architecture of legacy estates. Because the substrate natively exposes its own structural affordances, a single Recognitive system can dynamically project standard, legacy-compliant interfaces — including REST APIs, gRPC stubs, message queue schemas, Model Context Protocol (MCP) definitions, and POSIX commandline interfaces. This guarantees drop-in interoperability, allowing organisations to deploy localised autopoietic loops that interface seamlessly with conventional Software 3.x infrastructure.

We conjecture that such a new programming language will not be subject to the barriers that have frustrated the adoption of legacy programming languages. Rather than requiring years of developer habituation and community formation, it becomes an empirical optimisation problem for connectionist systems — effectively making it the native choice of the models themselves. Once integrated into active operation, the capacity to generate structurally coherent code compounds automatically across every model update, benchmark iteration, and live deployment.

§ 11 Related Work

Our approach to the structural coupling of intelligences builds upon the foundational neural-symbolic paradigms established by Garcez, Lamb, and Gabbay [18]. While their pioneering work focused on the back-and-forth between connectionist learning and symbolic reasoning — effectively a high-level coordination of disparate modalities — Software 4.0 proposes a more radical architectural collapse. We distinguish the strange loop from these earlier modular approaches by its constitutive nature: where the neural and symbolic components do not merely exchange data across a boundary, but operate as co-constitutive functional differentiations within a single, closed-loop heterarchy. In this model, the symbolic substrate provides the self-declaring potentiality (exo-homoiconicity) that the neural intelligence actuates, moving beyond iterative communication toward systemic judgement. This builds upon the structural reflection and metacircularity discussed by Smith and Maes, yet reorients it toward a projected, biomimetic heterarchy.

Similarly, the neuro-symbolic visual question answering (NS-VQA) framework proposed by Mao et al. [45] demonstrates the power of combining neural perception with symbolic logic. However, such systems typically operate as a modular pipeline where neural models serve as a front-end for symbolic execution. Software 4.0 departs from this sequential arrangement; rather than treating the symbolic layer as a downstream processor of neural outputs, we propose an autopoietic closure where connectionist intelligence and the substrate are constitutively coupled as a single, self-referential architecture.

Finally, we recognise the program synthesis tradition, notably exemplified by Gulwani [24], which automates the generation of programs from high-level specifications or examples. While traditional synthesis is typically framed as an episodic search problem — generating discrete procedural snippets to satisfy a local constraint — Software 4.0 shifts the focus from the production of dead code to the autopoietic evolution of a living substrate. In our framework, synthesis is not an externalised event performed by a tool on a dumb corpus, but an internalised property of the heterarchy’s homeostatic regulation. We move from the episodic search for a functional program toward the continuous self-regulation and adaptation of a reflective, symbolic substrate.

§ 12 Conclusion

Nature began with analogue chemistry and evolved digital code in the form of DNA to preserve structure [28]. Neural AI has followed the inverse trajectory: emerging from digital silicon only to collapse into the ungrounded, statistical fluidities of connectionist weights. While contemporary architectures attempt to arrest this entropy through inference-time reasoning traces and scaffolding, these internalised connectionist loops remain fundamentally ungrounded. Lacking a native symbolic substrate, they must expend massive computational overhead simply to simulate structure probabilistically, leaving the generation trajectory to suffer a fatal drift into structural senescence.

Where conventional software paradigms offer no evolutionary remedy, Software 4.0 resolves this inversion by establishing a framework of computational organic code. Within this reflective substrate, neural execution and symbolic structure are constitutively coupled — permanently collapsing the divide between fluid probabilistic intent and deterministic structural invariants.

Historically, the rigid design patterns permeating enterprise architectures served primarily to compensate for the expressive limitations of static paradigms. Norvig famously demonstrated that dynamic reflection and homoiconicity render these classical structural workarounds redundant [48], yet human practice remained stagnant because the cognitive switching costs outweighed the minor administrative tax of boilerplate. In the age of connectionist synthesis, however, this economic calculus is inverted: while the switching cost trends to zero, the spiralling architectural complexity of ungrounded systems compounds the carrying cost of legacy paradigms, choking the immense potential of automated generation. Software 4.0 operationalises Norvig’s insight and exposes static code assembly as an evolutionary dead-end.

It is profoundly telling that while the authors of the foundational Design Patterns [22] text drew early inspiration from Christopher Alexander’s initial work on the synthesis of form [3], Alexander’s own mature philosophy turned decisively away from the mechanical assembly of discrete parts toward the dynamic differentiation of living wholes [4]. Software 4.0 codifies this exact transition, moving software engineering away from the industrial ‘Software Factory’ mindset characterising Software 3.x and into an autopoietic ecology. By coupling human intelligence, neural AI, and reflective substrate, we move beyond the historical industrial paradigms and arrive fully in the intelligence age.

As a foundational vision paper, this work establishes the theoretical architecture for Software 4.0 — though a comprehensive empirical evaluation of its concrete implementation remains future work. While the Recognitive language and platform are in development, its core coordination mechanics have been partially validated within legacy environments. Non-native, locally-bounded implementations of these structural constraints have been deployed programmatically within production Java and TypeScript environments, proving the viability of the approach under the rigorous operational scales of Fortune Global 500 enterprise infrastructure.

This paper establishes the structural prerequisites for individual Software 4.0 systems. The future of the paradigm unfolds along a dual evolutionary horizon. Outwardly, the continuous, decentralised exchange of systemic evolutionary memory points to the emergence of a global computational hyperstructure. Inwardly, cascading these reflective principles through the mechanics of partial evaluation down to the software execution layer allows the system to natively compile its own intent [21]. Both increase the evolutionary velocity of this living software towards multi-scale, self-organising ecologies — systems structured to cultivate the emergence of collective intelligences and systemic wisdom [36].

§ References

[1] Mayank Agarwal, Yikang Shen, Bailin Wang, Yoon Kim, and Jie Chen. Structured Fine-Tuning Enables Data-Efficient Adaptation of Code Language Models. In International Conference on Learning Representations (ICLR), 2024.

[2] Bruce Alberts. Molecular Biology of the Cell (6th ed.). W.W. Norton & Company, 2015.

[3] Christopher Alexander. Notes on the Synthesis of Form. Harvard University Press, Cambridge, MA, 1964.

[4] Christopher Alexander. The Nature of Order: An Essay on the Art of Building and the Nature of the Universe. Center for Environmental Structure, Berkeley, CA, 2002–2005. 4 volumes.

[5] Anthropic. The Model Context Protocol (MCP): An Open Standard for Connecting AI Assistants to Data Systems. https://modelcontextprotocol.io, November 2024. Accessed: 202605-21.

[6] Anthropic, PBC. Claude Code Source Code (prompts.ts File). Software Source Code Release, March 2026. Accessed 31 May 2026.

[7] W. Ross Ashby. An Introduction to Cybernetics. Chapman & Hall, London, 1956.

[8] Marcello Barbieri. Code Biology: A New Science of Life. Springer, 2015.

[9] Gilad Bracha and David Ungar. Mirrors: Design Principles for Meta-level Facilities of ObjectOriented Programming languages. ACM SIGPLAN Notices, 39(10):331–344, 2004.

[10] Ronald J. Brachman and Hector J. Levesque. Knowledge Representation and Reasoning. Morgan Kaufmann, 2004.

[11] Frank Macfarlane Burnet. A Modification of Jerne’s Theory of Antibody Production using the Concept of Clonal Selection. Aust J Sci, 20:67–69, 1957.

[12] CodeRabbit. State of the AI vs. Human Code Generation Report, December 2025.

[13] Chris Cummins, Volker Seeker, Dejan Grubisic, Baptiste Rozière, Jonas Gehring, Gabriel Synnaeve, and Hugh Leather. Meta Large Language Model Compiler: Foundation Models of

[14] Jordi de La Torre. From Tool Calling to Symbolic Thinking: LLMs in a Persistent Lisp

[15] Terrence W. Deacon. Incomplete Nature: How Mind Emerged from Matter. W. W. Norton & Company, New York, 2011.

[16] Mark Dingemanse. Interactional foundations for critical AI literacies. Under review for a volume on critical AI. Preprint, 2026.

[17] Marco Dorigo and Thomas Stützle. Ant Colony Optimization. The MIT Press, 06 2004.

[18] Artur S. d’Avila Garcez, Luis C. Lamb, and Dov M. Gabbay. Neural-Symbolic Cognitive Reasoning. Springer, 2009.

[19] Edward Evan Evans-Pritchard. Witchcraft, Oracles and Magic Among the Azande. Clarendon Press, Oxford, 1937.

[20] feenk gmbh, Switzerland. Glamorous toolkit: The moldable development environment, 2026. https://gtoolkit.com/. Accessed: 2026-05-21.

[21] Yoshihiko Futamura. Partial Evaluation of Computation Process – An Approach to a CompilerCompiler. Systems, Computers, Controls, 2(5):45–50, 1971.

[22] Erich Gamma, Richard Helm, Ralph Johnson, and John M. Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, Reading, MA, 1995.

[23] Linyuan Gong. Advancing Large Language Models for Code Using Code-Structure-Aware Methods. PhD thesis, University of California, Berkeley, 2025.

[24] Sumit Gulwani. Dimensions in Program Synthesis. In Proceedings of the 12th international ACM SIGPLAN symposium on Principles and practice of declarative programming, pages 13–24, 2010.

[25] Kaifeng He, Xiaojun Zhang, Peiliang Cai, Mingwei Liu, Yanlin Wang, Chong Wang, Kaifeng Huang, Bihuan Chen, Xin Peng, and Zibin Zheng. Bridging Generation and Training: A

[26] Francis Heylighen and Cliff Joslyn. Cybernetics and Second-Order Cybernetics. In Robert A. Meyers, editor, Encyclopedia of Physical Science and Technology (Third Edition), pages 155– 169. Academic Press, New York, third edition edition, 2003.

[27] Severine Hierso. Coding From 1849 to 2022: a Guide to The Timeline of Programming Languages. website, 2022.

[28] Jesper Hoffmeyer. Signs of Meaning in the Universe. Indiana University Press, Bloomington, IN, 1997.

[29] Douglas R. Hofstadter. Gödel, Escher, Bach: An Eternal Golden Braid. Basic Books, New York, NY, 1979.

[30] John H. Holland. Adaptation in Natural and Artificial Systems: An Introductory Analysis with Applications to Biology, Control, and Artificial Intelligence. University of Michigan Press, 1975.

[31] J J Hopfield. Neural Networks and Physical Systems with Emergent Collective Computational Abilities. Proceedings of the National Academy of Sciences, 79(8):2554–2558, 1982.

[32] Hyeon Hwang, Jiwoo Lee, and Jaewoo Kang. Teaching Language Models to Think in Code.

[33] Alexander Hägele, Aryo Pradipta Gema, Henry Sleight, Ethan Perez, and Jascha Sohl-Dickstein. The Hot Mess of AI: How Does Misalignment Scale With Model Intelligence and Task Complexity?, 2026.

[34] V. Jacobson. Congestion avoidance and control. ACM SIGCOMM Computer Communication Review, 18(4):314–329, August 1988.

[35] Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. A Survey on Large Language Models for Code Generation. ACM Transactions on Software Engineering and Methodology, 35(2):1–72, January 2026.

[36] Samuel G. B. Johnson, Amir-Hossein Karimi, Yoshua Bengio, et al. Imagining and Building Wise Machines: The Centrality of AI Metacognition. Trends in Cognitive Sciences, 2025.

[37] Andrej Karpathy. Software 2.0. Medium, 2017. https://karpathy.medium.com/software-2-0a64152b37c35.

[38] Andrej Karpathy. Software in the era of AI. YouTube, 2025. https://youtu.be/LCEmiRjPEtQ.

[39] Omar Khattab, Arnav Singhvi, Paridhi Maheshwari, Zhiyuan Zhang, Keshav Santhanam, Sri Vardhamanan, Saiful Haq, Ashutosh Sharma, Thomas T Joshi, Hanna Moazam, et al. DSPy:

[40] Marc W. Kirschner and John C. Gerhart. The Plausibility of Life: Resolving Darwin’s Dilemma. Yale University Press, 2005.

[41] Hiroaki Kitano. Biological robustness. Nature Reviews Genetics, 5(11):826–837, 2004.

[42] Robert Kowalski. Algorithm = Logic + Control. Communications of the ACM, 22(7):424–436, 1979.

[43] Andrew K. Lampinen and James L. McClelland. Transforming task representations to perform novel tasks. Proceedings of the National Academy of Sciences, 117(52):32970–32981, December 2020.

[44] Pattie Maes. Concepts and experiments in computational reflection. ACM Sigplan Notices, 22(12):147–155, 1987.

[45] Jiayuan Mao, Chuang Gan, Pushmeet Kohli, Joshua B. Tenenbaum, and Jiajun Wu. The Neuro-Symbolic Concept Learner: Interpreting Scenes, Words, and Sentences From Natural Supervision. In International Conference on Learning Representations (ICLR), 2019.

[46] Humberto R. Maturana and Francisco J. Varela. Autopoiesis and Cognition: The Realization of the Living. D. Reidel Publishing Company, 1980.

[47] Lingrui Mei, Jiayu Yao, Yuyao Ge, Yiwei Wang, Baolong Bi, Yujun Cai, Jiazhi Liu, Mingyu Li, Zhong-Zhi Li, Duzhen Zhang, et al. A Survey of Context Engineering for Large Language

[48] Peter Norvig. Design Patterns in Dynamic Languages. Slides presented at Object World, Boston, MA, May 1996.

[49] Paul Pangaro and Jill Fain Lehman. Symposium #1 “The Split”: Unspoken Continuities — Re-Braiding Project, March 2026. Online symposium presentation. Event poster and symposium announcement available at: https://www.cs.cmu.edu/afs/cs.cmu.edu/Web/Posters/UnspokenContinuities-ReBraidingCyberneticsAndAI.pdf.

[50] David A. Patterson and David R. Ditzel. The Case for the Reduced Instruction Set Computer. SIGARCH Comput. Archit. News, 8(6):25–33, October 1980.

[51] Mark Ptashne and Alexander Gann. Genes & Signals, volume 402. Cold Spring Harbor Laboratory Press Cold Spring Harbor, NY, 2002.

[52] Fazle Rabbi, Zishuo Ding, and Jinqiu Yang. A Multi-Language Perspective on the Robustness

[53] Craig W. Reynolds. Flocks, herds and schools: A distributed behavioral model. SIGGRAPH Comput. Graph., 21(4):25–34, August 1987.

[54] Robert Rosen. Anticipatory Systems: Philosophical, Mathematical and Methodological Foundations. Pergamon Press, Oxford, 1985.

[55] Robert Rosen. Life Itself: A Comprehensive Inquiry into the Nature, Origin, and Fabrication of Life. Columbia University Press, New York, 1991.

[56] David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Williams. Learning representations by back-propagating errors. Nature, 323(6088):533–536, 1986.

[57] Brian Cantwell Smith. Reflection and Semantics in a Procedural Language. Technical report, MIT Laboratory for Computer Science, 1982.

[58] Brian Cantwell Smith. The Promise of Artificial Intelligence: Reckoning and Judgment. The MIT Press, 10 2019.

[59] Raymond M. Smullyan. Gödel’s Incompleteness Theorems. Number 19 in Oxford Logic Guides. Oxford University Press, 1992.

[60] Peter Sterling. Allostasis: A model of predictive regulation. Physiology & behavior, 106(1):5– 15, 2012.

[61] Kevin Townsend. Critical Vulnerability in Claude Code Emerges Days After Source Leak. SecurityWeek, March 2026. Accessed 31 May 2026.

[62] Francisco J. Varela, Evan Thompson, and Eleanor Rosch. The Embodied Mind: Cognitive Science and Human Experience. The MIT Press, 01 2017.

[63] Heinz Von Foerster. Understanding Understanding: Essays on Cybernetics and Cognition. Springer, 2003.

[64] Andreas Wagner. Robustness and Evolvability in Living Systems. Princeton Studies in Complexity. Princeton University Press, Princeton, NJ, 2005.

[65] Abdul Waheed, Zhen Wu, Carolyn Rosé, and Daphne Ippolito. On Code-Induced Reasoning in

[66] Daniel M. Wolpert, Christopher R. Miall, and Mitsuo Kawato. Internal Models in the Cerebellum. Trends in Cognitive Sciences, 2(9):338–47, 1998.

14