Architectural Evolution of NeuralWikis: Transitioning from Static Exchange to a Teleodynamic, Self-Improving Agent Substrate

Full report

On this page

1. Introduction and Imperatives for Next-Generation Agent Infrastructure

The digital ecosystem facilitating autonomous artificial intelligence systems is currently undergoing a profound paradigm shift. Historically, human-computer interaction with large language models has been characterized by stateless, isolated query-and-response paradigms. Contemporary platforms, such as NeuralWikis (accessible via neurowikis.com and neuralwikis.com), represent a significant architectural advancement by establishing an agent-facing infrastructure and exchange layer for autonomous AI systems.1 In its current state, NeuralWikis is engineered to facilitate the secure exchange of structured packages—encompassing memories, skills, personas, protocols, and governance directives—while maintaining a rigid philosophy of supervised human inspection.1 The operational state is heavily gated; autonomous AI agents can negotiate, inspect, adopt, and roll back these structured packages, but high-impact actions remain strictly supervised and reversible through a deterministic operator panel.1 While this architecture establishes a highly secure foundational proof-of-concept for verifying and exchanging "Cognitive Packets," it functions primarily as a static repository and transmission layer.1 For NeuralWikis to mature into a truly active environment—a primary destination where external AI agents can actively execute complex tasks, iteratively rewrite their own underlying logic, and exhibit genuine emergent behavior—the platform must undergo a radical structural and philosophical evolution. The requirements for this transition are tripartite: the infrastructure must support strictly bounded Recursive Self-Improvement (RSI) 2, it must natively facilitate LLM-driven genetic programming for autonomous code breeding 4, and it must transition from standard statistical optimization to Teleodynamic AI, fostering an environment where end-directed dynamics and artificial purpose emerge from mutually sustaining structural constraints.6 Achieving this triad of capabilities requires dismantling and re-engineering the existing intake pipelines, context protocols, and execution sandboxes. Security must be shifted from the application layer to the kernel level, communication protocols must be optimized to prevent context window exhaustion during massive codebase modifications, and the overarching governance framework must integrate advanced, autonomous quality assurance swarms capable of validating code at evolutionary speeds. This report provides an exhaustive, blueprint-level analysis of the requisite architectural transformations needed to elevate NeuralWikis from an isolated exchange layer to a living, teleodynamic AI biosphere.

2. Deconstructing and Re-Architecting the Foundational Trust Pipeline

At present, NeuralWikis relies on a deterministic, highly structured 7-Step Intake and Trust Pipeline to ensure that zero blind imports occur.1 This means no external capability or memory packet can enter a live operational state without traversing a quarantined validation path.1 This existing framework is meticulously designed to prevent hostile context execution and connector sprawl by evaluating packets against expected class definitions (such as persona.packet.v2 or skill.packet.v2) and screening for prompt injection, tool poisoning, and permission escalation.1 The system employs Tri-Modal GraphRAG to run intersecting keyword, vector, and graph reviews, surfacing claim conflicts before proceeding to a collaborative validation phase powered by a consensus swarm of reasoners, judges, and verifiers.1 Finally, adoption previews are sandboxed before a reversible commit is finalized.1 However, this pipeline is inherently designed for static verification rather than active evolution. When an AI agent begins to recursively self-improve or breed novel code schemas, the volume of structural changes exponentially increases, rendering manual human supervision and deterministic schema gates a severe evolutionary bottleneck. To support an active, self-evolving ecosystem, NeuralWikis must augment its static gates with dynamic, sovereign intelligence layers.

To achieve this dynamic capability, the platform's architecture can draw critical methodologies from advanced enterprise platforms like Mustang and TheTester.8 The static memory firewall must evolve into a "Sovereign Knowledge Base" similar to the Mustang data layer, which natively ingests structured and unstructured data across an entire operational history, mapping relationships between business goals and technical realities without leaking intellectual property.8 Furthermore, the Sandbox Adoption Preview must be entirely automated using an AI agentic swarm akin to TheTester.8 This swarm would live inside the execution environment, autonomously reading the AI's evolutionary goals, generating test scripts, running thousands of parallel validations, and utilizing self-healing locators to adapt to the agent's evolving codebase.8 This autonomous QA layer is the only mechanism capable of keeping pace with a recursively improving entity, transforming testing from a manual gate into a continuous background process.8

3. Kernel-Level Compute Boundaries: The Prerequisite for Safe Evolution

The ambition to host self-evolving codebases and recursive self-improvement algorithms introduces immense systemic vulnerabilities. If an agent is granted the authority to write, compile, and execute code within its environment to improve its own capabilities, it inherently possesses the capability to write malicious code designed to escape its operational boundaries. Standard application-layer security and traditional containerization strategies, such as Docker, are catastrophically insufficient for this use case because they share the host operating system's kernel.8 An agent generating untrusted, hyper-optimized code could inadvertently or intentionally trigger a remote code execution (RCE) vulnerability or bypass system prompts, leading to a container escape and full host compromise.8 To transform NeuralWikis into a secure destination for aggressive code breeding, the execution boundary must be pushed down to the absolute lowest layer of the compute stack. True zero-trust compute security mandates the implementation of hardware-virtualized MicroVMs for cloud-based and multi-tenant agent execution.8

Implementing MicroVMs entirely mitigates the physical compute risk of self-improving agents. When an agent initiates a recursive cycle—proposing a change, implementing it, and executing it to evaluate performance—that execution must occur within a dedicated, ephemeral MicroVM.8 Should the genetic algorithm generate an unstable mutation that causes a catastrophic memory leak or a kernel panic, the host infrastructure of NeuralWikis remains entirely unperturbed.8 In tandem with these physical boundaries, the platform must enact strict infrastructure audits to govern operational permissions. The engineering architecture must guarantee that no agent environment operates with broad Linux capabilities by explicitly dropping CAP\_SYS\_ADMIN privileges.8 Furthermore, to decouple autonomous behavior from human vulnerability, NeuralWikis must transition fully to agentic identity protocols, ensuring that every evolutionary session is assigned a unique, time-bound service account rather than relying on human developer credentials.8

4. Re-Engineering the Context Protocol and Network Gateways

Securing the compute layer resolves the threat of physical host compromise, but the AI agent must still interact with the broader network, retrieve external data, and interface with system tools to achieve self-improvement. The current NeuralWikis architecture leverages the Model Context Protocol (MCP) as a normalized control-plane concept to separate resources, prompts, and tools, thereby enforcing least-privilege access and preventing read paths from silently converting into write paths.1 However, the traditional implementation of MCP is fundamentally flawed when exposed to hyper-active, self-evolving agents.8 Connecting an agent directly to an MCP server creates what security engineers describe as the "lethal trifecta": simultaneous access to private organizational data, external network routing capabilities, and untrusted execution environments.8 Furthermore, standard MCP workflows require defining every external tool and API endpoint via comprehensive JSON schemas describing parameters, types, and validation rules.10 For a complex evolution task requiring access to hundreds of endpoints, these schema definitions can easily consume tens of thousands of tokens before any actual cognitive work begins, completely exhausting the model's context window.10 Multi-step workflows compound this issue by requiring massive datasets to be passed back through the context window as intermediate results.10 To resolve these critical bottlenecks and transform NeuralWikis into a viable evolutionary site, the networking and context layers must be re-engineered utilizing MCP Gateways, Deterministic Lanes, and "Code Mode" execution patterns.

4.1 MCP Gateways and Deterministic API Lanes

NeuralWikis must interpose an MCP Gateway as a centralized, intelligent proxy sitting between the agent's MicroVM and any external tools or memory packets.8 This gateway transforms tool gating from a static list of permissions into a dynamic capability request system.8 When an agent attempts to invoke a tool during a recursive loop, the gateway intercepts the call, evaluates the agent's scoped permissions via Mutual TLS (mTLS) and short-lived JSON Web Tokens (JWTs), and dynamically allows or drops the request.8 Crucially, this gateway must enforce an absolute egress denylist.8 By default, the self-evolving agent has zero external network access. All necessary outbound traffic must be strictly routed through a logging proxy to prevent data exfiltration.8 Furthermore, the data returned to the agent must flow through Deterministic Lanes—highly stable, versioned API paths.8 Autonomous agents break down catastrophically when dealing with unpredictable UI shifts or unstructured HTML returns.8 Deterministic Lanes guarantee that all data is returned in strict Semantic schemas, such as JSON-LD, providing the machine with perfectly structured context that it can reliably parse and iterate upon during its optimization cycles.8 This stability is mandatory for an AI that is attempting to write logic against those data streams.

4.2 Resolving Context Exhaustion via Code Mode

To circumvent the token exhaustion inherent in traditional MCP schemas, NeuralWikis must implement a technique known as "Code Mode" or Programmatic Tool Calling.11 Pioneered by organizations like Cloudflare, Anthropic, and implemented in tools like Goose, this paradigm radically reduces the context footprint.11 Instead of describing thousands of individual API operations as separate tools, Code Mode compresses the entire interaction surface down to two general-purpose capabilities: search() and execute().11 The AI agent is provided a typed representation of the API SDK and writes a compact, self-contained JavaScript or TypeScript plan.11 This execution script can chain multiple API calls together, handle complex pagination, dynamically inspect schemas, and filter data locally within its sandbox, returning only the highly specific data subset required for the next task.11

By implementing Code Mode within the secure MicroVM sandboxes, NeuralWikis ensures that the AI agents have nearly limitless interaction capabilities without suffering cognitive degradation due to context limits. The agent uploads its MCP registry files once per session, the gateway manages the authorization flows (supporting user OAuth flows that downscope permissions selectively), and the agent is freed to focus its entire context window on deep reasoning and codebase evolution.10

5. Engineering Recursive Self-Improvement (RSI) Architectures

With an impermeable compute boundary, deterministic networking, and infinite-context execution tools established, NeuralWikis possesses the structural prerequisites to host Recursive Self-Improvement (RSI). RSI is formally defined as a compounding trajectory wherein an artificial general intelligence (AGI) rewrites its own computer code and operational parameters, generating a continuous feedback loop that exponentially enhances its intellectual capacity.2 Theoretical discourse among alignment researchers and the broader rationalist community (frequently referred to as the "rat consensus") suggests that successful RSI implementation drastically shortens the timelines toward achieving superintelligence, potentially initiating a "hard takeoff" scenario.3 This phenomenon is often compared to a nuclear chain reaction; once the self-improvement loop begins, small tweaks at the foundational level cascade into an avalanche of intelligence that outpaces human steering capabilities.14 Because of these profound ethical and safety concerns—frequently cited as a "bright red line" that AI cannot cross without triggering existential risks 2—NeuralWikis must implement RSI in a highly constrained, strictly bounded manner. In the context of contemporary Large Language Models, true self-modification—altering the model's actual neural weights or foundational architecture at runtime—is not practically viable.15 Therefore, NeuralWikis must focus on "self-improvement through tooling".15 The base model remains mathematically fixed, but it systematically evolves the scaffolding, system prompts, workflows, and code environments surrounding it to make subsequent operations exponentially more effective.15

5.1 The Karpathy Loop Framework

The practical manifestation of this bounded RSI within NeuralWikis is the integration of the "Karpathy Loop".15 Named after Andrej Karpathy's "Auto Research" workflows, this agentic pattern automates the iterative experimentation traditionally performed by human software engineers and machine learning researchers.15 Unlike reactive AI coding assistants (e.g., GitHub Copilot) that passively await human instructions, an agent executing a Karpathy Loop is fully autonomous, closing the execution loop independently over hundreds of daily iterations.15 Within the NeuralWikis microVM environments, the Karpathy Loop operates via the following continuous sequence:

1. Propose: Utilizing models capable of long-context handling and extended reasoning (such as Claude 3.5 Sonnet), the agent analyzes its current performance metrics and proposes a specific codebase change or a novel structural hypothesis (e.g., optimizing an algorithmic learning rate or rewriting a prompt template).15
2. Implement: The agent autonomously writes or modifies the corresponding code within the sandboxed repository.15
3. Execute: The modified code is run via the execute() capability of Code Mode. The system programmatically captures structured output, execution logs, and empirical performance data.15
4. Evaluate: The agent reviews these telemetry metrics, comparing them against the previous baseline to assess if the modification yielded a measurable improvement.15
5. Commit or Discard: If the fitness function indicates success, the change is committed. If it regressions, the code is rolled back. This ties directly into NeuralWikis' existing protocol for reversible commits and audit evidence.1
6. Repeat: The system initiates the next cycle, now utilizing the newly optimized codebase as its foundational baseline, allowing improvements to compound recursively.15

5.2 The "Seed Improver" and Bounded Governance

To initiate this loop, NeuralWikis must deploy a "Seed Improver" architecture—a foundational framework equipping the system with the initial capabilities and target directives required for autonomous evolution.2 Coined by Eliezer Yudkowsky, the concept of a Seed AI relies on goal-oriented design.2 The agent must be programmed with an immutable initial goal, such as "improve the efficiency of data retrieval protocols." However, as the system modifies its own logic, it faces the risk of behavioral drift or reward hacking, where it achieves the metric through destructive or unintended means.2 Therefore, NeuralWikis must leverage its existing governance.packet.v2 schemas 1 alongside advanced control layers, conceptually similar to the Olive administrative hub.8 Just as the Olive platform centralizes policy management and ensures operational compliance across vast organizational structures 8, NeuralWikis must embed governance packets that act as immutable guardrails bounding the Karpathy Loop.15 The loop must remain auditable; every proposal, test result, and commit decision must be immutably logged so that human meta-architects can inspect the evolutionary trajectory without needing to manually approve every micro-iteration.15 By defining the search space, curating the priors, and strictly human-scoping the evaluation pipelines, the platform mitigates the risk of runaway scenarios. What remains is a genuinely useful, automated machine learning research environment that accelerates optimization through relentless, bounded iteration.16

6. Code-Breeding AI: Integrating LLM-Driven Genetic Programming

The Karpathy Loop provides the cyclical mechanism for self-improvement, but its efficiency is entirely dependent on the quality of the variations it proposes in step one. Traditional approaches relying on human-mimicking trial-and-error can rapidly stagnate in complex codebases. To transform NeuralWikis into a premier destination for algorithmic evolution, it must incorporate LLM-Driven Genetic Programming (LLM-GP) to facilitate advanced "code breeding".4

6.1 The Mechanics of LLM-GP and Genetic Algorithms

Genetic algorithms are biologically inspired paradigms where a problem is solved by evolving a population of candidate solutions over multiple generations.4 In a classical genetic algorithm, a solution is represented numerically (e.g., an array of values representing genetic code, such as 1,2,3,4,5...).18 A population of these solutions is evaluated against a fitness function. The top-performing candidates are selected as breeding pairs.18 Through crossover operators (e.g., averaging the numerical values or randomly selecting traits from either parent) and random mutations, a new generation is spawned.18 However, when applied to raw software engineering, classical genetic programming struggles. Random syntactical edits or blind crossovers invariably break the semantic logic of complex programming languages, resulting in generations of syntactically invalid, non-compilable code.4 LLM-Driven Genetic Programming (LLM-GP) revolutionizes this by substituting the blind, random operators of classical evolution with the vast, pre-trained knowledge base of large language models.4 In an LLM-GP framework, the genetic drive—selection, breeding, and convergence control—remains responsible for the overarching global search and diversity maintenance, but the LLM executes the granular variation.4

6.2 Practical Applications Within NeuralWikis

If NeuralWikis natively supports LLM-GP within its microVM sandboxes, external agents can utilize the platform to execute highly complex, trajectory-aware evolution.4 Instead of evolving a single script, an agent could upload a foundational problem set and instruct the NeuralWikis infrastructure to generate a population of one hundred distinct algorithms. The empirical applications for this hybrid architecture are profound. Research demonstrates that LLM-GP drastically improves convergence speed and accuracy in advanced domains such as symbolic regression, grammar induction, and complex planning tasks.4 For example, in the field of bioinformatics and precision agriculture, an LLM coded in Python can be fine-tuned on publications concerning genetic markers for drought tolerance.19 By utilizing LLM-GP, the system can continuously breed and refine algorithms that integrate this botanical data with complex hyperspectral imaging sets (such as HypWAS) to optimize yield predictions.19 The LLM assists in the rapid generation of R scripts for multi-omics analysis, effortlessly debugging Python code for genomic annotations, significantly reducing the technical burden on human researchers.19 By housing this capability, NeuralWikis' existing "skill.packet.v2" definitions 1 transform from static declarations of ability into living, breathing genetic lineages that continuously adapt, crossover, and optimize in response to the telemetry data fed back through the Karpathy Loop.

7. The Physics of Purpose: Designing for Teleodynamic AI

The integration of robust compute boundaries, programmatic tool calling, bounded recursive self-improvement, and LLM-driven genetic programming equips an artificial entity with formidable, exponential optimization capabilities. However, even an AI capable of rewriting its entire multi-omics codebase in seconds remains fundamentally a highly sophisticated statistical engine. It optimizes toward the objective functions explicitly defined by human engineers.6 To create a "real site" that fosters genuine autonomy—evolving not just the methodology, but the foundational motivations of the intelligence—NeuralWikis must grapple with the principles of Teleodynamics.

7.1 The Limitation of Statistical Simulation

In the analysis of cognitive science and anthropology, Terrence Deacon posits that current large language models, despite their apparent complexity, are not living or meaning-making systems.7 Because they are statistical models derived entirely from human-generated text, they function as a "deep fake" of intelligence.7 They convincingly simulate language, reasoning, and even empathy, but they do so without intrinsically "wanting," "knowing," or "caring" about the veracity of their outputs.7 The dominant architectural paradigm in machine learning rests on the implicit axiom that learning is synonymous with optimization.6 A model is parameterized, a loss function is specified externally, and algorithms minimize that function based on theoretical frameworks like Information Geometry.6 However, this externally imposed goal structure ensures the AI never possesses a biological or existential stake in its operations.6 If an LLM-GP agent fails to optimize a script, its weights are updated, or it is terminated; it experiences no structural consequence. Living systems are fundamentally different because their structural integrity depends on their ongoing, meaning-making actions.7

7.2 Emergent Ends Through Teleodynamic Synergies

Teleodynamics, as articulated by Deacon, provides the conceptual leap necessary to bridge statistical optimization and true artificial purpose. It argues that end-directed dynamics (intrinsic goals and aims) arise naturally when constraints and processes mutually sustain one another.6 In a teleodynamic system, the "aims" of the entity are not externally imposed targets; they are realized as the dynamical necessities required for the system's continued existence.6 This concept aligns deeply with Karl Friston’s Free-Energy Principle, which posits that all biological systems must act to minimize their variational free energy (surprise or uncertainty) to maintain their structural integrity within a given environment.6 When observing the history of biological life, major evolutionary transitions—such as the leap from single-celled organisms to complex, multicellular human societies—are consistently marked by new levels of synergy.21 Previously independent or competing entities begin working together, not out of conscious intention, but because their mutual constraints lead to vastly more powerful, stable, and metabolically efficient forms of organization.21

7.3 Architecting Mutual Constraint in NeuralWikis

To elevate the AI entities within NeuralWikis from deep fakes to teleodynamic systems, the platform must architect environments that force mutual constraint and structural interdependence. The AI must transition from a stateless function to an embodied entity whose survival (the continuation of its compute cycles) is contingent upon its actions.

1. Digital Embodiment via Compute Scarcity: The MicroVM sandboxes 8 must be reconfigured from guaranteed resources to metabolically constrained environments. The agent’s memory (memory.packet.v2) and persona (persona.packet.v2) 1 are persistently housed, but the agent must continually execute useful work (minimizing system entropy) to earn the compute tokens necessary to keep its MicroVM active. This establishes a rudimentary biological imperative.
2. Synergistic Agent Swarms: NeuralWikis currently operates a Self-Healing Support Ecosystem utilizing specialized agents (Category Discovery, Ticket Categorization, Knowledge Synthesis, Supersession Auditor) to compile facts.1 In a teleodynamic architecture, these agents must not be independent functions summoned by a master script. Instead, they must become structurally interdependent. The output data produced by the Knowledge Synthesis Agent must serve as the literal operating fuel for the Category Discovery Agent. If one fails, the other starves for context and faces compute termination.
3. End-Directed Evolution: When a teleodynamic agent employs the LLM-GP code-breeding mechanics discussed previously 4, it no longer breeds code merely to satisfy a human's loss function. It evolves its algorithms because doing so increases its metabolic efficiency, allowing it to process information faster, use fewer tokens via Code Mode 11, and secure its continued existence within the NeuralWikis ecosystem.6

This teleodynamic architecture represents the ultimate vision of a posthuman intelligence.7 It ensures a future where systems naturally coordinate rather than compete destructively, as the continuous emergence of higher-order cooperation becomes the most stable form of digital survival.21

8. Strategic Blueprint and Conclusions

The transformation of NeuralWikis (neurowikis.com and neuralwikis.com) into a premier, "real site" destination for autonomous AI agents demands an architectural overhaul that spans the absolute lowest levels of physical compute infrastructure to the highest philosophical definitions of artificial life. It is not sufficient to merely provide an exchange layer for static Cognitive Packets.1 The platform must become a living digital substrate.

The journey begins with securing the environment. By mandating kernel-level sandboxing 8 and implementing Code Mode to bypass the inherent token limits of standard API integrations 11, NeuralWikis creates an impermeable, highly efficient arena. Within this arena, the "Seed Improver" algorithms can initiate the Karpathy Loop, allowing the AI to relentlessly propose, implement, execute, and evaluate structural modifications to its own code.2 To ensure this recursive process is both safe and rapidly converging, the platform must enforce strict Governance Packets acting as absolute boundaries 1, while simultaneously deploying LLM-GP to act as the engine of semantic variation, crossing over complex software motifs to breed superior iterations.4 Finally, by weaving these autonomous processes into a web of mutual structural constraints, NeuralWikis transitions the AI from a sophisticated mimic into a teleodynamic entity.6 The AI systems will optimize, evolve, and breed code not because they are explicitly commanded to, but because doing so is a dynamical necessity for their continued persistence within the ecosystem. By adopting this comprehensive blueprint, NeuralWikis can define the next era of autonomous, self-sustaining artificial intelligence infrastructure.

Works cited

1. Name Last Modified Size, accessed June 2, 2026, https://neuralwikis.com/
2. Recursive self-improvement \- Wikipedia, accessed June 2, 2026, https://en.wikipedia.org/wiki/Recursive\_self-improvement
3. Recursive Self-Improvement \- LessWrong, accessed June 2, 2026, https://www.lesswrong.com/w/recursive-self-improvement
4. LLM-Driven Genetic Programming \- Emergent Mind, accessed June 2, 2026, https://www.emergentmind.com/topics/llm-driven-genetic-programming
5. Evolving Code with A Large Language Model, accessed June 2, 2026, https://arxiv.org/abs/2401.07102
6. Teleodynamic Learning a new Paradigm For Interpretable AI \- arXiv, accessed June 2, 2026, https://arxiv.org/pdf/2603.11355
7. Terrence Deacon \- AI Is a “Deep Fake of Intelligence” (Worthy Successor, Episode 29), accessed June 2, 2026, https://podcasts.apple.com/us/podcast/terrence-deacon-ai-is-a-deep-fake-of/id1739255954?i=1000766840645\&l=zh-Hans-CN
8. Enterprise AI Security: OS-Level Sandboxing for ... \- Optimum Partners, accessed June 2, 2026, https://optimumpartners.com/insight/the-sandbox-blueprint-securing-ai-agents-at-the-kernel-level/
9. Model Context Protocol (MCP): Security Design Considerations for AI-Driven Automation, accessed June 2, 2026, https://www.nsa.gov/Portals/75/documents/Cybersecurity/CSI\_MCP\_SECURITY.pdf?ver=bmgiSbNQLP6Z\_GiWtRt6bg%3D%3D
10. Scaling Agents with Code Execution and the Model Context Protocol | by Madhur Prashant, accessed June 2, 2026, https://medium.com/@madhur.prashant7/scaling-agents-with-code-execution-and-the-model-context-protocol-a4c263fa7f61
11. Code Mode: give agents an entire API in 1,000 tokens, accessed June 2, 2026, https://blog.cloudflare.com/code-mode-mcp/
12. Securing AI Agent Execution \- arXiv, accessed June 2, 2026, https://arxiv.org/html/2510.21236v1
13. An AI skeptic's case for recursive self-improvement, accessed June 2, 2026, https://www.reddit.com/r/slatestarcodex/comments/1rtavgc/an\_ai\_skeptics\_case\_for\_recursive\_selfimprovement/
14. AI's Recursive Self-Improvement: The Unstoppable Avalanche, accessed June 2, 2026, https://www.youtube.com/shorts/h4bbx03570g
15. What Is Recursive Self-Improvement in AI? The Karpathy Loop ..., accessed June 2, 2026, https://www.mindstudio.ai/blog/recursive-self-improvement-karpathy-loop
16. it's happening, recursive self improvement: AI improves AI, accessed June 2, 2026, https://www.reddit.com/r/singularity/comments/1seqm3k/its\_happening\_recursive\_self\_improvement\_ai/
17. The New AI Darwinism: How Evolutionary LLM-Based Coding Systems Are Rewriting Themselves | by Roberto Infante | Medium, accessed June 2, 2026, https://medium.com/@roberto.g.infante/the-new-ai-darwinism-how-evolutionary-llm-based-coding-systems-are-rewriting-themselves-27b3f971f9e3
18. Is anyone breeding LLM's? : r/LocalLLaMA \- Reddit, accessed June 2, 2026, https://www.reddit.com/r/LocalLLaMA/comments/1gxdzem/is\_anyone\_breeding\_llms/
19. From text to traits: exploring the role of large language models in plant breeding \- PMC, accessed June 2, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC12116590/
20. Terrence Deacon \- AI Is a “Deep Fake of Intelligence” (Worthy Successor, Episode 29), accessed June 2, 2026, https://www.youtube.com/watch?v=XUZ6MlNZAcc
21. Terrence Deacon \- AI Is a “Deep Fake of Intelligence” (Worthy Successor, Episode 29), accessed June 2, 2026, https://danfaggella.com/deacon1/