Traditional software has never been truly autopoietic in the strict biological sense defined by Maturana and Varela: living systems that continuously self-produce and self-maintain their own organization through their own processes, without needing an external “builder” to recreate or sustain their boundary and components.
Classical software is paradigmatically allopoietic — produced and maintained by something outside itself (human developers, compilers, ops teams, etc.). It doesn’t autonomously regenerate its own code, repair structural degradation over time, or adapt its core architecture without external intervention.
Bugs accumulate, dependencies rot, and without humans patching or refactoring, it eventually ceases to function coherently. What you’re observing in modern multi-agent loops especially in 2025–2026 agentic systems does rhyme strongly with autopoiesis.
Operational closure + recursive self-reference — In strong multi-agent setups; Anthropic-style orchestrator + sub-agents, self-healing code swarms, or frameworks like AutoGen and LangGraph with reflection/correction loops, the system runs closed loops where agents critique, debug, refine prompts/tools/code, evaluate outputs, and feed improvements back into the next cycle.
Register for Tekedia Mini-MBA edition 20 (June 8 – Sept 5, 2026).
Register for Tekedia AI in Business Masterclass.
Join Tekedia Capital Syndicate and co-invest in great global startups.
Register for Tekedia AI Lab.
The “organization” (the agent graph, prompts, tool definitions, memory) is reproduced and adapted through the system’s own operations. Self-maintenance & self-repair — Monitor ? Diagnoser ? Rewriter ? Executor loops allow the system to detect drift/failures and rewrite parts of itself (code, prompts, agent roles) without a human opening an IDE. This mirrors how a cell maintains its membrane and metabolic network.
The agent swarm defines and polices its own scope: rejecting invalid actions, spawning sub-agents for specialization, pruning underperformers, or evolving tool descriptions autonomously. This has an autopoietic flavor — preserving the system’s coherence amid environmental perturbations.
Emergent Self-Production
In the most advanced examples; self-evolving agents, recursive code optimizers, or “AI co-scientist” setups, the loop produces new capabilities, better versions of agents, or even training data that feeds back — creating a self-referential acceleration that’s reminiscent of autopoietic recursion.
Recent demonstrations include: Architectures where agents autonomously rewrite their own source code after runtime failures. Systems that generate, test, and integrate new tools and skills in closed loops. Multi-agent research setups that self-diagnose prompt/tool flaws and iterate ~40% faster task completion through internal self-prompt engineering.
These create something that participates in its own maintenance and evolution far more than any previous software paradigm. Despite the rhyme, most current implementations remain operationally open in critical ways: The base models (LLMs), compute, and energy are not self-produced — they’re supplied externally (data centers, electricity, human engineers updating weights or deploying new versions).
The initial architecture, agent definitions, and high-level goals are still human-imposed bootstraps. The system doesn’t spontaneously generate its own first boundary or closure from scratch. Long-term structural integrity often still depends on human oversight; approving rollouts, handling catastrophic forgetting, or intervening when loops diverge.
No full metabolic closure — there’s no internal “energy” economy or component regeneration analogous to cellular metabolism. In other words: we’re seeing strongly autopoiesis-like dynamics at the software/behavioral level, but the substrate remains allopoietic. It’s more like an autopoietic simulation running on an allopoietic machine than a fully autopoietic entity.
If trends in recursive self-improvement, autonomous agent spawning, and closed-loop evolution continue and 2025–2026 research strongly suggests they will, we could approach something much closer: Agents that bootstrap successors with modified architectures. Systems that negotiate their own compute, resources via APIs/markets.
Loops that include model fine-tuning or synthetic data generation internally. At that point the rhyme becomes a near-homage — software exhibiting proto-autopoietic properties at scale. Whether that ever becomes genuine autopoiesis; requiring perhaps embodied robotics, novel hardware, or a different ontological substrate is a deeper philosophical question.
Multi-agent recursive loops are the closest thing we’ve ever built to software that participates in producing and maintaining itself. It’s not life yet — but it’s starting to hum with some of the same strange, self-sustaining music.