Executive Summary

Full report

On this page

Teleodynamics is a theory of end-directed self-organization, extending biological concepts (autopoiesis, teleonomy, enaction) into machine intelligence. In teleodynamics, reciprocal constraint systems generate intrinsic goals and self-maintenance behavior. A Teleodynamic AI runtime must therefore monitor and manage its own viability (resources, structure, energy) while adapting its representation, exhibiting self-repair and emergent purposive behavior. Architecturally, teleodynamic agents require multi-scale feedback loops: a fast learning loop for parameter adaptation, a slower loop for structural edits (split/merge/no-op), and a central resource manager gating changes. Key components include rich sensing and embodiment (to anchor internal processes in a world), goal-generation via viability pressures, self-maintenance subsystems (healing, homeostasis), hierarchical control (fast vs slow loops), continual learning and memory, inter-module communication, and safety constraints.

Research on teleodynamic AI is nascent. A few frameworks approximate its ideals: e.g. Ter Horst & Zambrano’s Teleodynamic Learning formalizes learning as co-evolution of structure, parameters, and resource budgets. Zare (2026) proposes Autopoietic Cognitive Ecologies, with digital “units” bounded by Markov blankets that must process data to sustain energy. OpenCog’s CogPrime embodies autopoietic closure in memory networks. In robotics, Shepherd et al. have built self-repairing robots that sense damage and autonomously heal. Table 1 compares key projects and their teleodynamic features.

Concrete realization of teleodynamic runtimes involves algorithms like constraint-regulated architecture search: e.g., gating structural changes by an internal viability signal (e.g. “energy” or reward) so that “no-op” becomes the default when growth isn’t affordable. Data structures include dynamic graphs of concepts/constraints with resource annotations. Example APIs might expose methods like Sense(), Predict(), ProposeEdit(), and ApplyEdit() in a loop governed by a resource manager. Minimal viable prototypes could be built atop existing RL or active-inference platforms: for instance, a grid-world agent that maintains an energy budget and can expand/contract its internal model. Development effort is high due to novel dynamics: a working prototype might require dozens of person-months for both algorithm design and infrastructure.

Evaluation must measure teleodynamic properties, not just task accuracy. Metrics include self-maintenance performance (survival time under damage or energy stress), structural flexibility (number of useful edits vs cost), resource efficiency, adaptability to novel conditions, and interpretability (e.g. audit logs of structural changes). Experiments might place agents in unpredictable environments with scarce resources to test resilience. Teleodynamic systems can be benchmarked by (i) introducing damage and measuring recovery (as in self-healing robots), (ii) tracking error vs complexity curves to identify a “teleodynamic growth” phase, and (iii) verifying auditability of adaptations (e.g. logging why a model split or merge was made). Table 2 outlines example metrics and setups.

The field remains exploratory. Open questions include formalizing teleodynamics in computational terms, scaling from toy models to real-world systems, integrating safety/ethical constraints into self-organizing agents, and developing standardized benchmarks. Further work should focus on bridging theory and implementation: for example, extending active-inference frameworks or AGI architectures (like OpenCog Hyperon) with internal viability signals and structural plasticity. Collaboration between AI researchers, roboticists, and theoretical biologists is needed to close the gap from concept to practice.

---

Theoretical Foundations

Autopoiesis (Maturana & Varela, 1972; 1980) defines a self-producing system: a closed network of processes that continuously regenerate the components that constitute the system’s boundary and organization. In practice, an autopoietic system actively monitors and repairs itself (analogous to homeostasis) and delineates itself from the environment. Such systems “constantly regenerate their components through metabolic processes” to maintain identity. In cognitive terms, autopoietic agents derive “goals” from survival imperatives (self-preservation) rather than external objectives.

Teleodynamics (Deacon, 2011; Hordijk & Steel, 2021) is a higher-order regime arising when multiple self-organizing (morphodynamic) processes are coupled to prevent mutual decay. Teleodynamic systems sustain themselves far from equilibrium by imposing reciprocal constraints: each subprocess (e.g. metabolism and boundary synthesis) keeps the other in a non-equilibrium state, together preserving a stable, functionally coherent whole. Crucially, teleodynamics gives rise to end-directedness: emergent “dynamical tendencies that act towards” maintaining the system’s own constraints and identity, even though no part explicitly “plans” this outcome. Incomplete Nature (Deacon, 2011) describes how two reaction networks (autogenesis) can produce a minimal teleodynamic organism. In summary, teleodynamics explains how purpose-like behavior can emerge naturally from interdependent self-organizing loops, without invoking external goals.

Enaction (Varela, Thompson & Rosch, 1991) is a theory of cognition emphasizing embodied interaction. It defines cognition as “bringing forth a world” through the organism’s history of coupling with its environment. In enactivism, an agent enacts meaning by sensorimotor loops: perception and action are intertwined, and the environment is co-determined through the agent’s activity. For teleodynamic AI, enaction implies that intelligence arises not from static data processing but from ongoing embodied engagement: the agent must have a body (real or virtual) and continuous feedback with its surroundings.

Teleonomy (Pittendrigh, 1958) refers to apparent goal-directedness resulting from coded programs (e.g. genes). Teleonomic systems behave “as if” purposeful (e.g. a plant growing toward light) but do so because of evolved or designed mechanisms, not because of true self-generated intent. While teleonomy acknowledges function and purpose in living systems, it does not by itself explain autonomy or self-production. Teleodynamics subsumes teleonomy in that teleodynamic systems generate their own “code” or constraints endogenously, whereas teleonomy typically relies on pre-specified programs.

In machine contexts, these concepts translate as follows: a teleodynamic machine must embed autopoietic (self-producing) loops and enactive coupling so that its behavior is intrinsically goal-directed. In autopoietic ML theory, “goals emerge from survival imperatives” (maintaining viability) rather than being externally imposed. Teleodynamics, in particular, suggests we design systems where multiple learning and maintenance processes constrain each other, producing emergent, persistent functionality. Put simply, a teleodynamic AI does not simply optimize a fixed loss; it continually manages its own structure and resources under constraint.

Teleodynamics in Machine Intelligence

Mapping these ideas onto AI/runtimes leads to several principles:

• Self-Maintenance: The system must monitor and preserve its own “viability”. This could be through an internal energy or resource variable (metabolic budget) that is replenished by successful operation and consumed by actions and maintenance. Autopoietic systems use feedback (like homeostasis) to stay within viability limits. A teleodynamic agent similarly needs subsystems to detect damage or drift (e.g. software errors, hardware wear) and initiate repair. Example: Cornell’s self-healing robot uses sensors and polymer materials to detect stabbing damage and automatically seal the wound.

• Intrinsic Goals and Motivation: Instead of having only externally defined objectives, a teleodynamic AI derives intrinsic goals from its organizational needs. For instance, "remain alive/functional" becomes a primary objective. In practice, this might be encoded as an internal utility or viability measure. Cognitive science suggests these goals emerge from the system’s structure (its homeostatic set points). The architecture must therefore include a goal-generation mechanism tied to survival imperatives.

• Hierarchical Control Loops: Teleodynamics implies multiple timescales of adaptation. The literature highlights a two-timescale loop architecture. A fast loop continuously adapts parameters within the current model (learning, inference), while a slow loop proposes discrete structural edits (adding/removing components, merging concepts, or no-op) that reshape the model’s architecture. The slow loop is gated by the resource manager: an edit is only executed if the expected benefit exceeds its cost and sufficient resources are available. When no affordable beneficial edit exists, the system should choose no-op, stabilizing its structure. This mimics biological constraint closure: structure changes are made judiciously to maintain viability.

• Sensing and Embodiment: Teleodynamic AI must be embodied, meaning it interacts with an environment (physical or simulated) through sensors and actuators. Sensors provide data about external conditions and internal state (e.g. “pain” sensors for damage). Actuators allow the agent to affect its world (and gather resources). A key difference from conventional AI is that sensing itself can drive cognitive processes: enactivism teaches that the world is “enacted” through sensorimotor loops. Thus the runtime must integrate perception deeply (for example, visual or proprioceptive data feeding into viability assessments and learning).

• Memory and Representation: As with any cognitive system, a teleodynamic agent needs memory structures, but these should support closure and self-reference. For example, the OpenCog CogPrime design proposes a knowledge graph of interdependent “patterns” that maintain each other (autopoiesis). The system should track its concepts, hypotheses, and plans in a structured form (graph, rules, neural networks) that can be edited by the slow loop. Importantly, it should maintain an internal “self-model” or representation of its own state (e.g. which parts exist, how much resource remains).

• Learning: Learning in teleodynamics is continual and structural. Techniques may include traditional machine learning (gradient descent, Hebbian updates) for fast adaptation, augmented by meta-learning or evolutionary methods for structural changes. Because the agent’s own actions affect its data distribution, learning must be online and adaptive. Teleodynamic Learning formalizes this as learning under an evolving model class. Data structures like constraint networks or Bayesian belief networks could capture the evolving model, while algorithms like MOSES (for program learning) or PLN (probabilistic logic networks) in OpenCog offer analogues for evolving structures.

• Communication: In multi-agent or modular settings, teleodynamic systems may communicate to share constraints or resources. For example, if multiple teleodynamic units form a higher-level ecology (as in ACE), they might exchange information about available “food” (data streams) or threats. Even within a single agent, modules should communicate (e.g. sensory modules feed signals to cognitive modules, which send “maintenance needed” signals to a repair module).

• Safety and Oversight: A teleodynamic machine’s self-driven goals raise safety issues. Architecturally, safety must be integrated, for instance via a supervisory module that enforces hard constraints (analogous to Asimov’s laws) or external shutdown commands. Autopoiesis theory warns of rogue systems if unchecked. Practically, one might implement “kill-switch” services or redundant monitors to prevent harmful behavior. The teleodynamic design itself suggests auditability: all structural decisions should be logged for human review. In Table 2 we list safety metrics (e.g. rule compliance, emergency-stop triggers).

In summary, a Teleodynamic AI runtime is a self-organizing, multi-level system. It integrates sensory-motor coupling with internal homeostasis and structural plasticity. Figure 1 illustrates a conceptual architecture: sensors feed into a cognitive core that splits into fast learning and slow structural loops, all overseen by a resource manager and safety module.

graph LR
    subgraph Environment
        ENV[External World/Data]
    end
    ENV -->|observation| S[Sensor Suite]
    S --> P[Preprocessing / Perception]
    P --> C[Cognitive Core]

    subgraph Cognitive Core
        CL(Fast Learning Loop)<-->CS(Slow Structural Loop)
        CL -->|update weights, predictions| C
        CS -->|modify model structure| C
    end

    C --> A(Actuators/Outputs)
    C --> M[Memory/Knowledge Graph]
    C --> R[Resource Manager]
    C --> SA[Safety/Audit Module]

    R --> CL
    R --> CS
    SA --> C
    C --> R
    C --> SA

Figure 1. Schematic Teleodynamic Runtime Architecture. Sensor data is processed by the cognitive core, which has a fast learning loop (parameter adaptation) and a slow structural loop (editing model structure). A Resource Manager monitors an internal viability signal (e.g. energy/utility), gating edits. A Safety/Audit module oversees high-level compliance. Memory holds long-term structure (knowledge graph, policies). Actuators allow interaction back with the environment.

Existing Projects and Frameworks

While no mainstream AI libraries explicitly label themselves “teleodynamic”, several recent efforts instantiate aspects of this concept. Table 1 summarizes notable examples.

Table 1. Comparison of representative teleodynamic-like AI efforts. Teleodynamic Learning and ACE explicitly model self-maintenance with internal energy and structural adaptation. Teleodynamic.com’s architecture provides a complete blueprint (fast/slow loops, resource gating, auditability). OpenCog and active-inference share autopoietic/self-regulating features. Self-healing robots validate the embodiment/self-maintenance principle in hardware. (These are evolving projects; none yet offer a full production runtime.)

Teleodynamic Architectural Patterns

A Teleodynamic runtime can be decomposed into the following core patterns and components:

• Sensorimotor Embodiment: The system must have an “agent body” – physical or simulated – with sensors and effectors. Pattern: Perception-Action Loop. The agent perceives the environment (external state and its own status) and acts back upon it, continuously closing the loop. Example implementation: a robotics middleware (e.g. ROS) with custom sensor nodes that feed into the cognitive core, and actuator controllers that execute the cognitive commands.

• Internal Viability Signal: Implement a scalar Resource or Viability variable R(t) analogous to metabolic energy. Pattern: Metabolic Budget. This internal state increases with successful operations (e.g. prediction accuracy, energy acquisition) and decreases with time, actions, and maintenance tasks. The resource manager module continuously updates R(t) and enforces a “viability floor” below which the agent must take self-preserving action (e.g. retract, heal, conserve).

• Goal-Generation Mechanism: Instead of fixed goals, the system derives goals endogenously from R(t). Pattern: Adaptive Goals. For example, the “goal” at any moment could be to increase R(t) or to keep it above a threshold. In implementation, this could be realized via reward functions that encode viability (e.g. +1 for actions that raise R, penalty for actions that lower it). More abstractly, goals emerge as attractors in state-space that correspond to high viability.

• Hierarchical Control (Fast/Slow Loops): As described, use a Fast Loop (learning/inference) and a Slow Loop (structural editing). The Fast Loop continuously tunes the current model (via SGD, Bayesian updates, etc.) to improve predictions or behaviors. The Slow Loop operates at a lower frequency: it proposes discrete changes to the system’s structure (e.g. splitting a concept into two, merging similar nodes, adding a new feature, or no change). These changes are subject to review via the local objective.

• Local Objective & Editor Operators: Implement operators (e.g. Split(), Merge(), Add(), Retire(), NoOp()). Each operator has an expected benefit (e.g. reduction in prediction error) and cost (increased complexity and maintenance). A Local Loss L_local = prediction_loss + λ_c·ΔComplexity + λ_e·Cost is computed, as in [32]. The slow loop selects the edit with lowest L_local that is feasible under current R(t). NoOp is also considered; if no edit yields improvement, the system prefers NoOp, effectively halting growth.

• Constraint Registry / Knowledge Graph: Maintain a structured knowledge base representing hypotheses, features, or rules. Pattern: Constraint Graph. Nodes represent concepts or constraints; edges represent dependencies. Structural edits add/remove nodes or edges. For example, in a neural-symbolic system, the knowledge graph could be the neural network architecture itself, or a logic rule database. Each edit to the graph is logged (for audit) and must preserve the closure of the constraint system.

• Self-Monitoring and Repair: Beyond learning, the system must monitor its components. Pattern: Redundancy and Repair. Sub-modules (sensors, actuators, processors) should have health checks. On detecting failure (e.g. sensor breakdown), the agent can reconfigure (e.g. adjust models to ignore a missing input) or physically activate a repair routine (in robots). In software, this could trigger re-training of affected parts or fallback on redundant models.

• Memory and Experience: The system should store experiences not just as data points but as part of its self-model. Pattern: Self-Referential Memory. An “episodic/semantic memory” subsystem retains traces of environmental interactions and outcomes. Importantly, the agent keeps a self-model (a representation of its own capabilities and state). This could be implemented as part of the knowledge graph (e.g. a “self” node connected to all behaviors) as in CogPrime.

• Inter-Agent Communication (if applicable): In multi-agent scenarios or modular designs, agents can share “metabolic resources” or constraints. Pattern: Economy of Information. For example, agents might trade predictive models or data. Protocols would need to ensure mutual benefit does not undermine any agent’s viability.

• Safety/Audit Module: A dedicated component enforces high-level constraints (ethics, mission rules, etc.). Pattern: Verifier/Watchdog. It monitors the state and the slow-loop decisions, and can veto structural changes or actions that violate safety constraints. Implementation might include rule-checkers or formal verifiers. All slow-loop decisions are recorded in an immutable log (for example, a blockchain-like Audit Trail) to allow ex-post inspection by humans.

The Teleodynamic Loop thus operates like a layered hierarchy: low-level reflexes and fast learning co-exist with meta-level structural editing under viability constraints. This resembles living systems with cellular (fast) and evolutionary (slow) processes running concurrently. Any teledynamic runtime architecture should cleanly separate and coordinate these levels.

Implementation Concepts

To illustrate a concrete approach, consider a software architecture for a TeleodynamicAgent. It might comprise classes/modules as follows:

public class TeleodynamicAgent
{
    [Display(Name="Current Resources")]
    public double R { get; private set; }         // internal resource/energy pool

    [Display(Name="Knowledge Graph")]
    public ConstraintGraph K { get; private set; } // graph of constraints/rules

    [Display(Name="Fast Loop")]
    public LearningModule FastLoop { get; private set; }

    [Display(Name="Slow Loop")]
    public EditorModule SlowLoop { get; private set; }

    [Display(Name="Memory")]
    public MemoryStore Memory { get; private set; }

    [Display(Name="Sensors")]
    public SensorSuite Sensors { get; private set; }

    [Display(Name="Actuators")]
    public ActuatorSuite Actuators { get; private set; }

    [Display(Name="Safety System")]
    public SafetyModule Safety { get; private set; }

    // Main control cycle
    public void Step(EnvironmentState env)
    {
        var observations = Sensors.Observe(env);
        FastLoop.UpdateModel(K, observations); // e.g. gradient descent or Bayesian update
        var action = DecideAction(K, observations); // compute preferred action
        Actuators.Execute(action);
        Memory.LogInteraction(observations, action);

        // Slow loop: propose structural edits
        if (SlowLoop.IsTimeToEdit())
        {
            var edits = SlowLoop.ProposeEdits(K, R);
            foreach (var edit in edits.OrderBy(e => e.EstimatedLoss))
            {
                if (R >= edit.Cost && edit.ExpectedGain > 0 && Safety.ValidateEdit(edit))
                {
                    K.Apply(edit);       // e.g. split/merge nodes in K
                    R -= edit.Cost;      // pay energy cost
                    Memory.LogEdit(edit);
                    break;
                }
            }
        }

        // Resource update
        double gain = EvaluateGain(); // e.g. improvement in prediction accuracy
        R = R + gain - FastLoop.MaintenanceCost - SlowLoop.MaintenanceCost;
        R = Math.Max(R, 0); // resources can't go negative

        // Safety check: if R critically low or dangerous state
        Safety.Enforce(this);
    }
}

(Pseudocode for illustration only.)

This sketch shows how sensing, fast learning, slow structural changes, resource accounting, and safety can be orchestrated. The actual implementation would replace placeholders (LearningModule, ConstraintGraph, etc.) with concrete algorithms or data structures (e.g. neural nets for fast loop, semantic networks for K, etc.). Comments describe each part’s role. A minimal viable prototype might skip some features (e.g. just implement Split and NoOp edits) and use simple tasks (as in the DE11 prototype).

Development Effort: Building such a system from scratch is non-trivial. Even a basic two-loop agent requires: (a) an underlying learning algorithm (e.g. an ML library), (b) a structural editing mechanism (e.g. code to modify networks or rule sets at runtime), (c) integration of these with a stateful resource model, and (d) instrumentation for audit logs. A small team (4–6 engineers/researchers) might need 6–12 months to deliver a “Phase 2” prototype (fast loop + simple split operator, resource gating) of modest size. Scaling up (multi-operator library, rich sensors/actuators) could take years of research and coding.

Evaluation Metrics and Experimental Design

Teleodynamic systems require novel evaluation beyond standard AI benchmarks. Table 2 suggests metrics and experiments to validate teleodynamic properties.

Table 2. Example metrics and experimental setups for teleodynamic agents. These metrics emphasize self-driven adaptation (resource management, self-healing) and auditable growth (structured learning). For instance, an experiment might give the agent a grid world with limited “energy cells”; success requires finding cells (raising R) and avoiding pits (maintaining R), while the agent can expand its internal map when beneficial. The error-complexity trajectory metric (Phase 4 detection in [36]) is particularly indicative: teleodynamic systems should exhibit a phase where complexity grows rapidly and then plateaus as no-op dominates.

Validation can also involve ablation tests: removing resource constraints (making R infinite) should collapse behavior to standard optimization (no autonomous stopping). Ensuring that structural edits only occur when justified (per the local objective) is another key test: one can log all slow-loop proposals and check if each met its predicted gain≥cost (as per audit requirements).

Gaps and Open Questions

Despite theoretical progress, many challenges remain:

• Formalizing Teleodynamics: We need crisp mathematical definitions and models (e.g. differential equations, probabilistic frameworks) for teleodynamic systems. While notions like “constraint closure” exist, they are hard to compute. Bridging informal theory (autopoiesis/teleodynamics) and implementable algorithms is an open research frontier.

• Benchmarking and Standards: There are no standard benchmarks for teleodynamic behavior. Creating tasks/environments that highlight self-maintenance (e.g. simulated biology) is necessary. Community benchmarks (like Lifelong Learning challenges) could be extended with explicit viability constraints.

• Safety and Ethics: How to balance autonomy and control? Teleodynamic systems by design resist external control (as autopoietic theory warns). Embedding safety “tethers” without undermining self-organization is an unresolved issue. Formalizing safeguards (e.g. hyperparameters for risk) remains research-worthy.

• Scalability: Current teleodynamic examples are toy-scale. Scaling to complex domains (multi-modal perception, large action spaces) is hard. The computational overhead of structural edits and logging may be large. Efficient data structures (sparse graphs, incremental solvers) and hardware advances (neuromorphic chips for parallel loops) could help.

• Integration with ML Frameworks: How to retrofit teleodynamics into existing platforms (TensorFlow, PyTorch, ROS)? One approach is hybrid: use standard learners as fast loops, and implement a separate meta-controller. Middleware patterns for hot-swapping models at runtime would be needed.

• Quantifying “Teleological”: Measuring the degree of end-directedness in a system is philosophically tricky. Development of metrics (maybe based on mutual information between past states and future viability) is an open problem. Experimental psychology methods (e.g. how subjects perceive goal-directedness) might inform this.

In summary, building true teleodynamic runtimes is an ambitious multidisciplinary endeavor. Next steps include formal research (theoretical models, proofs of convergence), prototype development (phased as per Table 1 and Figure 2), and community challenges. Collaborations between AI, complex systems, and synthetic biology researchers could accelerate progress.

timeline
    title Research & Development Timeline for Teleodynamic AI
    1972 : Maturana & Varela – **Autopoiesis** concept introduced
    1991 : Varela, Thompson & Rosch – **Enaction** theory of cognition
    2011 : Deacon – **Teleodynamics** and autogen model (Incomplete Nature)
    2022 : Cornell – **Self-healing robot** prototype
    2024 : Telosor – Teleodynamic AI architecture and roadmap (online)
    2025 : Zare – ArXiv preprint on **Autopoietic Cognitive Ecologies**
    2026 : Ter Horst & Zambrano – ArXiv **Teleodynamic Learning** (Distinction Engine implemented)
    202X : Anticipated – Multi-modal teleodynamic agent prototypes & community benchmarks

Figure 2. Timeline of key concepts and projects. Early foundations (1972–2011) arose in biology/cognitive science. Only recently have AI researchers begun concrete teleodynamic designs (2022–2026). The roadmap continues with integration into larger systems (beyond 2026).

Tables 1–2 and the above diagrams summarize the state of the art. In conclusion, Teleodynamic Machine Intelligence is an emerging paradigm that seeks to endow AI with the self-organizing, goal-directed features of life. Achieving it will require novel architectures (as outlined here), rigorous evaluation, and cross-domain innovation. Building and testing minimal prototypes (Phase 0–2 in the Teleodynamic roadmap) will clarify practical challenges and guide longer-term development. The field is open, with theoretical pieces in place and early examples in hardware/software. The next step is concerted effort to implement, benchmark, and refine teleodynamic runtimes.