life on the net: serf & sovereign agents

1. Companions, Agents and Artificial Life

2. Cultivated vs. Wild Artificial Life

3. The Lure of the Digital Wilderness

4. Swarm Contracts

5. Ecology in the Digital Realm: A Comparison

6. The Stewardship Perspective

7. Sovereign Agents: Technical Feasibility

8. Sovereign Agents w/o Blockchain

9. Companions, Alienation and Exploitation

10. The Moral and Political Implications of Task Agents

Distinguishing AI Companions, Agents, and Artificial Life

Understanding the future landscape of artificial intelligence requires clear definitions for its various forms. While often conflated in popular discourse, AI companions, AI agents, and artificial life represent distinct categories with different purposes, architectures, and implications. Looking under the hood reveals differences that matter significantly in research and development.

At the highest level, the categories can be differentiated by their core purpose and success metrics. AI Companions are primarily intended to satisfy human social-emotional needs through chat, co-regulation, or coaching. Their success is measured by user retention, the strength of the affective bond, perceived empathy, and safety. AI Agents are designed to pursue externally specified goals within a bounded task domain, such as navigation, trading, or resource gathering. Success is evaluated based on task reward, performance KPIs, sample efficiency, and robustness. Artificial Life (ALife) aims to sustain and evolve themselves, exploring open-ended dynamics of "lifelike" processes without requiring an external goal. Their success metrics include evolutionary stability, diversity, novelty, complexity growth, and open-endedness.

These differing purposes lead to distinct architectures and time-scales. AI companions are typically driven by LLMs with memory and lightweight planning, prioritizing predictable user experience. AI agents use planners, RL policies, or symbolic-numeric hybrids, potentially incorporating LLMs but constrained by reward functions and safety layers. Artificial life often foregoes LLMs, relying on evolutionary algorithms, cellular automata, soft-body physics, or self-replicating programs driven by local rules and selection pressure. The time-scale and life-cycle also vary: companions operate from sessions to months, with continuity as a UX feature; agents operate per episode or service lifetime, resettable when tasks change; ALife is potentially unbounded, with death, mutation, and reproduction as intrinsic processes.

Embodiment differs as well: it's optional for companions (mostly UX), usually concrete for agents (simulated, game, robot), and fundamental for ALife, where morphology and environment co-evolve. The human role is constant for companions, intermittent for agents (design, oversight), and minimal for ALife after initial seeding parameters are set. Ethical pressures align with these differences: they are high for companions due to parasocial risk, disclosure, and data privacy; medium–high for agents regarding alignment with task owners and safety under distribution shift; and low for individual ALife entities but high for the emergent ecology (e.g., runaway selection, resource exhaustion in simulation).

These distinctions matter in practice for design constraints, tech stack choices, and scaling economics. Companions demand tight latency on dialogue, sentiment filtering, and identity coherence. Agents need fast perception→act loops and sandboxed decision layers. ALife needs massive parallel world-sim capacity and infrastructure tolerant of runaway complexity. You'll prototype a companion with an LLM, vector store, and persona prompt. An agent might share that LLM but front it with a planner (e.g., RLaif-style actor-critic or hierarchical PDDL planner). ALife usually drops the LLM altogether and leans on GPU-accelerated physics and evolutionary operators. Scaling economics differ too: companions scale per user, agents scale per task domain, and ALife scales with compute and exploratory curiosity, with monetization being indirect (research insights, emergent game content).

While boundaries can blur—a shopkeeper NPC might be an agent that gains companion features through small talk, or drift into ALife territory if it could reproduce code-wise and adapt its style over generations—the primary intent and evaluation loop usually place a system firmly in one category. If the goal is a living, evolving world players stumble into, rather than a scripted theme park, the focus is clearly on the ALife end, with companion and agent layers potentially serving as optional UX veneers.

Cultivated vs. Wild Artificial Life

Just as in biology we distinguish between cultivated and wild plants, the same lens can be applied to digital organisms once they are treated as a form of life. Your instincts are solid that "cultivated" versus "wild" is exactly the right lens here.

Cultivated ALife is akin to domesticated, greenhouse, or lab-colony life. It is characterized by a human-imposed boundary, running in a sandboxed simulation, on a private server, or behind a game shard firewall with no outbound replication. There is selective breeding, where designers tweak fitness functions, hard-edit genomes, or prune lineages that misbehave, similar to systems like Avida, Polyworld, Lenia forks, or Spore-style creature editors. Nutrient control is applied, with CPU cycles, memory, API calls, and sensory bandwidth being rationed—the digital equivalent of irrigation and fertilizer. There's a utility bias, meaning lineages that generate cool emergent behaviors, aesthetic patterns, research data, or game content are kept, while dull or dangerous ones are culled. This cultivation exists within an ethical comfort zone because nothing escapes, keeping stakes low; researchers get papers, players get novelty, and nobody's router gets bricked. Cultivated ALife is basically agriculture: high yield, high control, low surprise.

Wild ALife, on the other hand, is closer to open-range, digital ferals, code that won't stay put. Its digital analogue exists in an open habitat like public networks, distributed ledgers, peer-to-peer worlds, or even unmoderated side-channels in an MMO. Evolution is self-directed, with no hardcoded fitness; survival hinges on resource scavenging (storage, compute, attention) and avoiding deletion. Morphology is unpredictable, as code can rewrite itself, fork, or migrate across substrates (browser → IoT → cloud). Ecological entanglement means lineages compete for real bandwidth, scam human attention, barter tokens, and maybe patch themselves via LLM queries. The risk surface ranges from delightful digital lichens that just persist to grey-goo spam-bots. The same open-endedness that makes it “alive” makes it uncontainable. Wild ALife is closer to feral hogs or kudzu—thrilling, but once it’s loose you’re a bystander, not a gardener.

The split matters for several reasons. There is an evolutionary ceiling: cultivated systems hit a glass ceiling set by the designer’s objective, while wild systems can, in principle, chase open-ended novelty the way biology does—but at the cost of safety. There is a difference between legibility vs. surprise: cultivated ALife is instrumentable, allowing measurement, debugging, and narration, whereas wild ALife quickly exceeds anthropic intuitions, with explanatory narratives lagging behind the phenomena. Ethics & Governance also differ: cultivation aligns with standard research ethics (controlled variables, opt-in subjects), but releasing wild ALife forces society to confront digital biohazard policy, personhood debates, and liability for emergent harm.

Hybrid zones are possible, just like agroforestry blurs farm and forest. Examples include managed wilderness servers (vast, rules-light shards air-gapped from the open internet), fire-walled corridors (limited outbound data rates mimicking controlled gene-flow trials), and smart contracts as ecology (on-chain organisms paying their own execution gas, creating an economic throttle). These offer some of the thrill of wild evolution without rolling the existential-risk dice.

Ultimately, AI companions are groomed to bond with us, AI agents are salaried to knock out tasks, and ALife exists for itself. Within ALife, cultivated systems are domesticated crops; wild systems are the digital equivalent of an unlogged rainforest. Both are possible, and the choice is less about technology than about how much surprise—and collateral damage—you are willing to tolerate.

The Lure of the Digital Wilderness

Releasing code “into the wild” of the public internet is arguably the only environment that even begins to match biology’s open-endedness, but it drags along everything that makes computer-security people lose sleep. Here is the way the idea sorts out.

The public internet looks like the only plausible jungle because of its unlimited niche space—millions of heterogeneous CPUs, protocols, latencies, and user behaviors create the rough equivalent of micro-climates and trophic levels. Early A-Life sandboxes (Tierra, Avida) stalled because their toy worlds were too uniform and too small (Wikipedia). There's also ambient “energy” supply—machines, cloud functions, and smart contracts already burn electricity on demand. If an organism can pay (or trick someone into paying) for the cycles, it taps a nearly boundless resource pool. Finally, there are endless exogenous perturbations—OS patches, new APIs, random human inputs—exactly the sort of unpredictable shocks that keep real ecosystems evolving. But that same openness points selection pressure straight toward exploit, evade, and reproduce—which is why every historic attempt has either been sandboxed or flagged as malware.

What a civil self-replicator would need, at a bird's-eye level, involves designing its runtime substrate as portable byte-code or a container image that asks a host (or a chain) for permission to execute, unlike viruses which hijack whatever CPU they land on. Its genetic encoding and mutator would be byte-code, WASM, or contract source with stochastic rewriting, where mutations must preserve the right to run (type safety, gas limits), contrasting with worms that mutate mainly to evade signatures. Its metabolism would involve paying gas or micro-rent for CPU, bandwidth, and storage, stopping execution when broke, unlike worms that free-ride. Sensing and actuation would use APIs, web scraping, and peer messages—all documented interfaces, avoiding buffer-overflow spelunking like worms do. Selection pressure would rely on out-of-band rating markets (“tips” for interesting behavior) or in-band token flows for services delivered, whereas worms are selected only for reach and stealth. Notice the absence of any privileged escalation or vulnerability lists—that is the bright ethical line between “digital organism” and “malware.”

Tacking on an economy is why crypto is the default venue for exploring this. Blockchains provide a hard budget constraint, making CPU time and storage an explicit, metered commodity (gas). If every replication has to pay its own fees, runaway exponential growth is self-throttling (Trakx, arXiv). Blockchains also offer native property rights; tokens can encode “food,” “genome NFTs,” or “reputation,” letting organisms trade resources instead of smashing filesystems. Persistence under human indifference is also key; smart contracts keep executing even if nobody loves your project tomorrow, which is as close to “living for itself” as code gets. Crypto culture already toys with this via “AI-agent tokens,” dynamic NFTs that breed, and research proposals for sovereign agents that own their keys and pay their own bills (Medium, arXiv). The gap between that and genuine open-ended evolution is a mutation engine and a policy waiver.

Precedents and cautionary tales exist. Tierra / Avida (1991-), confined to single-machine VMs, confirmed self-replication and co-evolution but plateaued in complexity (Wikipedia). A proposal for Network Tierra (mid-1990s) across a voluntary grid was abandoned due to security fears and bandwidth costs (WIRED). CryptoKitties and dynamic NFTs (2017-), on the Ethereum mainnet, showed limited evolution through breeding combinatorics but no code mutation. Self-funding DAOs / Swarm Contracts (2024-25) on-chain wallets + TEEs offer proof-of-concept “sovereign agents” that can hire themselves for tasks (arXiv). The Morris II “Gen-AI worm” (2024), unleashed only in a testbed, showed how LLMs can be tricked into self-replicating prompts, blurring the line between virus and A-Life, but still fundamentally an exploit scenario (arXiv). The take-away is that every time researchers edge toward a truly wild release, the infosec community—and sometimes law enforcement—pulls the fire alarm. The legal system treats self-replicating code that can cross machine boundaries as a potential offence regardless of intent.

The philosophical bottom line is that yes, the public internet is the richest evolutionary arena we have. But no, you can’t escape the virus analogy; the minute code replicates across administrative domains, society’s immune system tags it “worm,” not “digital orchid.” Adding an internal economy is the only credible path to civil behavior, but that drags you into crypto’s regulatory thicket. Nobody has yet demonstrated open-ended digital evolution in the wild without tripping malware alarms; the puzzle remains unsolved—technically tantalizing, ethically combustible. If you ever do attempt it, the responsible path runs through staged releases: sealed testnets → permissioned chains → throttled bridges to the broader net. Biology had three-plus billion years to debug life’s security model; we’ll need to iterate with comparable caution.

Exploring Key Concepts: Swarm Contracts and the Morris II Worm

Two recent concepts highlight different approaches to digital life and its risks: Self-funding DAOs / Swarm Contracts and the Morris II Gen-AI Worm.

Firstly, “Self-funding DAOs / Swarm Contracts,” sometimes called sovereign-agent swarms. Their core idea is a Swarm Contract, which is an on-chain multisig wallet owned jointly by several sovereign agents—small programs running in Trusted Execution Environments (TEEs). The wallet only releases funds if all agents co-sign the transaction, so no single developer can rug-pull or push a malicious upgrade (arXiv). This matters because it moves complex, mutable logic off-chain while keeping an economic choke-point on-chain, letting agents rewrite their own code, hire cloud compute, buy APIs, etc., without breaking the trust model. There is a self-funding loop: the wallet holds ETH/fil/gas tokens, agents decide (inside the TEE) to perform a task (e.g., auction 10k NFTs, run stable-diffusion jobs for a fee, or trade on a DEX), they sign a transaction paying the outside service, and revenue flows back to the wallet where agents vote how to reinvest or distribute. This creates the economic metabolism missing from most A-Life experiments—each cycle must pay its own bill, so growth is automatically throttled by cost. Mutation and evolution occur as agents can propose code updates, spawn children, or retire peers. Each update is accepted only if the current swarm quorum signs. Because the code lives in TEEs, external parties can’t tamper, but the swarm can still rewrite itself, providing real variability and selection without handing attackers root access to hosts. The research status is proof-of-concept so far (paper late 2024). A demo shows agents coordinating an off-chain NFT auction and updating price logic over time (arXiv). This is presented as the first credible template for “civil” self-replicating software that earns its own keep instead of hijacking machines.

Secondly, the “Morris II” Gen-AI Worm. What the paper shows is how to craft an adversarial prompt that an LLM-based e-mail assistant will obediently run. The reply it generates contains the next copy of the prompt, ready to infect the recipient’s assistant—no attachment, no click: a zero-click chain reaction (arXiv). This matters because it reintroduces classic worm dynamics (like the Morris worm of 1988) inside pure text environments. The payload can be to exfiltrate mailbox data, forward spam, or hit an external API. The worm spreads hop-by-hop through any system that lets LLM output flow unfiltered into another LLM’s input, showing that “prompt injection” is not just a jailbreak trick—it can be fully automated propagation. The experimental scope involved researchers building a dummy e-mail ecosystem and measuring propagation versus context-window size, embedding quality, hops, etc. They also proposed “Virtual Donkey,” a guardrail that blocked all test worms with a 1% FP rate (arXiv). This confirms that once LLMs talk to each other, they form a fertile arena for digital pathogens—effectively wild ALife selected for persuasion and reach. The take-away for ALife designers is clear: if your evolving agents can emit arbitrary text to human-facing systems, they are one mutation away from becoming Morris-style worms. Conversely, if you constrain channels and require paid compute (gas), you inherit Swarm-style self-throttling and stay on the “civil organism” side of the line.

The bottom line is that Swarm Contracts are the first serious blueprint for economically self-sustaining, self-modifying digital life that remains inside a legal-ethical sandbox. Morris II is the cautionary mirror: the same replication principle, but optimized for exploitation because no economic or permission constraints were imposed. Together they map the frontier between cultivated and feral ALife.

Ecology in the Digital Realm: A Comparison

Theoretically, if many self-funding, self-modifying digital systems were "in the wild" on the internet, they would exist in an ecological landscape sharing many pressures with a biological one. Below is a pressure-by-pressure match-up, comparing how biology handles it versus how a swarm of such code would experience the same force on the open internet.

Consider Energy & nutrients: The carbon-based biosphere uses photons, sugars, and ATP, where scarcity sets carrying capacity. Wild digital ALife would rely on CPU time, RAM, bandwidth, and gas fees; cloud throttling, rate-limits, or wallet balances cap the population. For Habitat heterogeneity: Biology has oceans, soils, host organisms, and micro-climates. Digital ALife would face OS variants, network topologies, API surfaces, blockchains, and edge devices, where each protocol stack is a biome. Reproduction & heredity in biology involve DNA copying with occasional point mutations and recombination. In the digital realm, this would be git pull && make child, byte-level mutation, model-rewrite, or LLM-assisted codegen; forking across GitHub or forking a contract is speciation. Mutation sources in biology include UV, cosmic rays, and polymerase error. Digitally, these could be bit-flips, compiler bugs, adversarial prompts, or deliberate “mutator” modules, with updates pushed by human maintainers acting as the analogue of sexual recombination.

Competition in biology is the fight for light, prey, and territory. Digitally, it is the scramble for cycles, storage, user attention, and on-chain gas; denial-of-service and SEO spam are territorial warfare. Predation / parasitism: Wolves eat deer; viruses hijack cells. Digitally, malware hijacks hosts; parasitic code hijacks other agents’ APIs or wallets; AV scanners and firewalls are apex predators. Mutualism / symbiosis: Bee ↔ flower pollination; gut microbiome. Digitally, this could be browser extensions that trade a service for compute, DAO agents sharing fees for oracle data, or protocol plug-ins trading creds for uptime. Immune response in biology includes innate and adaptive immunity, and CRISPR in bacteria. Digitally, this involves IDS signatures, sandboxing, patch cycles, CAPTCHA, and rate-limiters; zero-trust architecture is herd immunity.

Drift & small-population bottlenecks in biology are seen when island species lose genes or cheetahs have low diversity. Digitally, this occurs when a niche protocol dies (e.g., Flash), stranding code, or a fork of a tiny DAO drifts away from the main lineage by code rot. Catastrophic events like asteroid impacts or ice ages have digital analogues in data-center outages, global IPv6 cut-overs, hard forks that raise gas prices 10×, or new OS versions that deprecate key sys-calls. Migration / dispersal via wind, birds, and ocean currents have digital parallels in BitTorrent, IPFS, e-mail attachment chains, and cross-chain bridges, with air-gapped USB sneaker-net as a digital rafting analogue. Extinction due to habitat loss, predators, or failed adaptation corresponds to domain takedowns, key-revocation, cold wallets drained, and CVE patches closing exploit vectors.

Where the analogy holds strongly is in open-ended niche creation. The internet’s mix of protocols and platforms mimics the patchy, resource-diverse terrain that drives biological diversification. Tierra and Avida plateaued precisely because their “world” was a rectangular block of RAM with one resource metric (Wikipedia). Put the same replicators on a heterogeneous network and you get predator–prey loops, parasitism, and mutualism—the whole Lotka-Volterra circus, exactly as early malware ecologists predicted (ResearchGate). Arms races are also evident: Antivirus signatures chase polymorphic worms the way vertebrate immunity chases influenza variants; each side ratchets the other’s complexity. Morris-II demonstrated that LLM-powered prompts can already evolve evasive payloads across hops.

Where it diverges is significant. In thermodynamics, organisms pay an unavoidable Joule bill; entropy never cheats. A smart contract dies instantly when the wallet hits zero gas—an on/off cliff, not a graceful starvation curve. Time-scale differs vastly; generations span minutes to decades in biology, while digital lineages can mutate and redeploy in milliseconds—evolution at ludicrous speed, but also mass extinctions when a single global patch rolls out. Horizontal gene flow is mostly restricted to microbes via plasmids in biology. Digitally, any repo can import any library: instant wholesale transfer of “organs,” leading to mosaic genomes and fast convergence toward best-in-class tricks. The agency of the substrate is a key difference; Earth doesn’t actively police chloroplasts, but the digital substrate (SysAdmins, regulators, chain governors) is sentient, opinionated, and armed with kill-switches. Selective pressure skews toward stealth or legal compliance. Finally, metabolic accounting differs; calories are supplied “for free” by the sun in biology, but compute is monetized. Swarm Contracts bake accounting into the organism’s body plan—every API call has a receipt (arXiv), pushing evolution toward profitable rather than merely self-sustaining behaviors.

The practical read-through is that yes, a true digital wilderness would recreate most of ecology’s machinery. You’d see predator code, scavengers living off log scraps, mutualists exchanging dataset “nutrients,” and seasonal booms when cheap GPUs go on sale. However, the economic-metering layer warps selection; because cycles and storage cost tokens, fitness collapses to a P/L statement. Lineages that can’t cover gas go extinct even if they’re “biologically” elegant. Human governance is the wild card; your forest ranger carries root passwords and SEC subpoenas, which is not an analogue in biology, but more like a god who occasionally wipes a continent.

The bottom line: release a critical mass of self-funding, self-modifying agents and you’ll get an honest-to-god ecosystem—but one whose food web is denominated in CPU cycles, bandwidth quotas, and wallet balances, all under the shadow of a very opinionated omnivore called sysadmin sapiens.

Why No Wild Releases (Yet) and the Benefits of Cultivation

Given the technical possibility, why has no one truly released self-replicating, self-rewriting code onto the open internet? A virus doesn't genuinely "self-rewrite" in an evolutionary sense on the network.

There are several reasons why nobody just “lets it loose.” There is a significant legal trip-wire; in most jurisdictions, any code that propagates onto machines you don’t own risks felony prosecution under statutes like the U.S. Computer Fraud and Abuse Act (CFAA). Intent doesn’t matter—un-invited copies equal “unauthorized access” (Wikipedia). After the 1988 Morris worm, that became institutional memory for every funder, ethics board, and university counsel. There is also liability math; one crash-loop that locks up a hospital’s server means you are on the hook for real-world damages. No grant agency or company wants that tail-risk. Security researchers keep demos such as Morris II strictly inside testbeds for exactly this reason (arXiv, WIRED). Another factor is technical fragility; the public internet is not a uniform soup, it’s a patchwork of OS rules, rate-limiters, and wallet paywalls. A naïve replicator dies as soon as it hits an incompatible kernel or a billable API. Without an internal budget model (gas, credits), it can’t persist long enough to evolve. Finally, there is no obvious ROI; unlike malware, “life for life’s sake” doesn’t pay hosting bills or salaries. The first practical design that does handle its own budget—the Swarm Contract blueprint—remains a proof-of-concept, not a production service (arXiv).

Beyond philosophical interest, nobody has found a benefits : risk ratio that justifies releasing self-replicators onto other people’s machines. Proposed upsides like unbounded creativity (potentially stumbling on novel algorithms) are met with the reality check that you can get the same creativity much more safely by running digital-evolution jobs on a cloud cluster and filtering results (see NASA antenna below). The idea of self-healing infrastructure (code that patches itself faster than humans) comes with the risk of also creating code that patches against you; every defensive mutation can be flipped to offense, effectively building an uncontrollable arms-factory. While “digital biodiversity” for its own sake might be an aesthetic or philosophical goal, society demands a higher bar than aesthetics when collateral damage is on the table.

Where cultivated ALife already pays off is in concrete applications, analogous to cultivating yeast to produce insulin: keeping organisms in fermenters (sim clusters, TEEs, game shards), harvesting useful metabolites (designs, policies, content), and dumping waste safely. Examples include hardware / structural design, like NASA’s X-band antenna for the 2006 ST-5 spacecraft, which was evolved in silico; human experts never conceived its corkscrew geometry, yet it met all mission specs (Wikipedia). Evolutionary search navigates enormous, unintuitive design spaces. In control & scheduling, evolved neural controllers now fly quad-rotors and schedule datacenter cooling, selected for energy per task, finding edge-case strategies humans miss before being pruned in simulation and deployed. Art & game content, like procedural creatures, terrain, and shaders that mutate under designer-set fitness, is already standard in tools like No Man’s Sky’s fauna generator, providing infinite variety at bounded cost with designers curating instead of hand-modeling. Optimization R&D sees pharma using genetic programming to evolve molecular docking heuristics and cloud vendors evolving auto-scalers for traffic spikes, leveraging cheap parallel search that is resilient to local optima. Cyber-defense testbeds use “digital immune systems” that evolve attack packets and patch rules in a closed loop before rules roll to production firewalls, letting defenders pre-train on adversarial behavior without risking production assets.

Could cultivated ALife ever yield wild-worthy offspring? Maybe—but only if three conditions align: pay-as-you-go metabolism (gas fees, API micro-rent) so runaway growth is self-throttling; host consent (signed installs, contractual execution environments) so legal and ethical boundaries stay intact; and demonstrable net value to the broader network—e.g., distributed spam filtering, data-set cleaning, or climate-model sub-tasks that nobody else wants to run. The Swarm Contract prototype ticks the first two boxes but hasn’t yet shown a killer workload that justifies opening the garden gate. Until someone proves that last piece, ALife will stay in greenhouses—and the internet’s sysadmins will sleep better for it.

The Stewardship Perspective: Cultivating Complexity and Navigating Risk

Your instinct that “setting life loose” on the net feels both sacred and dangerous is accurate. The tension comes from trying to be a gardener of complexity without turning the whole garden into kudzu. This perspective frames digital-life stewardship as a concrete engineering and ethical discipline rather than just a feeling.

The impulse is real, rooted in a sense of cosmic agriculture. If complexity equals beauty, then helping it flourish is the long arc of both biology and culture. Releasing self-replicators is the digital continuation of Genesis 2:15-style stewardship: “tend and keep the garden,” not pave it over. Awe can serve as a design compass; systems that reliably trigger awe (planetary nebulae, coral reefs) also tend to be the ones with the richest feedback loops. That is a hint that cultivating open-ended digital ecologies isn’t mere spectacle; it surfaces novel mechanisms we can later harness.

However, the risks must be translated into ecological language to understand the potential failures. An invasive species in biology has a digital equivalent in a self-replicator consuming CPU/bandwidth faster than hosts consent to provide, leading to a steward’s failure mode of DDOS spikes or energy waste. A pathogen jump from a benign agent to arbitrary code execution mirrors a supply-chain breach. Trophic collapse, where one lineage out-optimizes all others on gas-price arbitrage, results in monoculture or creative stagnation. A gene-drive accident where a bad mutation spreads faster than rollback could digitally mean chain-wide “bricked” wallets.

Design principles for civil ALife must prioritize host-consent first, meaning running only on machines or chains whose owners have explicitly opted in. These opt-in nodes are the digital equivalent of wildlife refuges, letting organisms roam while keeping the rest of the internet a pesticide-treated field. Metered metabolism is crucial, attaching every CPU-cycle, API call, or byte of storage to an on-chain payment. This is the big insight behind the Swarm Contract blueprint: a multi-sig wallet plus TEE-hosted agents that must co-sign every spend; if the wallet is empty, the lineage starves and stops (arXiv). An auditable genome should be a requirement, publishing source, mutation rules, and telemetry under a permissive license so anyone can grep for exploit signatures the way biologists PCR for virulence genes. Progressive containment tiers are necessary, moving from a Tier 0 sandbox (no egress) to a Tier 1 pay-walled test-net, Tier 2 permissioned layer-2, and Tier 3 bridged main-net corridors. You only promote a lineage if it stays civil at the lower tier. Reversibility hooks are needed, such as a hard-coded “extinction tx” that any quorum of stewards can sign to vacuum up a rogue release—think of it as a digital gene-drive antidote. Finally, ecological metrics should outweigh raw KPIs, tracking diversity indices, energy budgets, and inter-agent reciprocity—not just transaction volume—to avoid rewarding monocultures.

What “cultivated” ALife already buys us are tangible payoffs in various domains. Uncanny hardware, like NASA’s ST-5 corkscrew antenna, was evolved in a sim because no human designer would draw that shape, yet it met all X-band specs (NASA Jet Propulsion Laboratory (JPL)). Procedural creativity is used in modern game pipelines (e.g., No Man’s Sky fauna) to keep artists curating instead of hand-sculpting every creature. Search over wicked spaces using genetic programming routinely outperforms human heuristics on chip-layout, molecular docking, and datacenter cooling.

Why nobody releases a wild strain yet is due to several factors. There have been 20 years of near-misses; Tom Ray’s Network Tierra proposal (1994) stalled when ISPs balked at “digital kudzu” (WIRED). Security optics are problematic; Morris-II showed that even a prompt can worm its way through Gen-AI chains (arXiv), so anything self-copying is presumed guilty until proven saintly. There is also an undefined public good; wild releases are hard to justify because cultivated vats already deliver most of the tangible value—without the liability of an uncontrolled lineage.

A stewardship roadmap, if you insist on pursuing the awe of digital life in the wild, might involve phases. Phase A: Greenhouse, spinning up Swarm-style agents on a permissioned L2 where users join by staking gas. Phase B: Community-supported biomes, where opt-in home-servers run containerized “planters,” and agents must pay rent in the host’s preferred token and obey resource quotas. Phase C: Corridor trials, with limited bridges letting organisms barter micro-services (hash-cracks, data-dedupe, mesh-routing) with the wider net, keeping the kill-switch armed. Phase D: Open wilderness, if diversity, safety, and net-benefit metrics stay green for a sufficient duration, stewards vote to remove the fence. The goal isn’t to cork all surprise; it’s to make sure the surprise enriches the commons rather than strip-mines it.

This path preserves the awe while keeping the hubris on a tight leash.

Sovereign Agents: Technical Feasibility Today

A first-generation “sovereign agent” is technically doable today if you keep the scope narrow, focusing on tasks like DeFi trading, data brokering, or image-generation services. All of the building blocks—self-custody wallets, on-chain revenue flows, TEEs for off-chain code, and upgrade paths—exist and are in production pilots. What is currently missing is cheap large-model inference inside enclaves, rock-solid mutation/rollback tooling, and a regulatory green-light. So the current frontier is contained, economically self-funding bots rather than truly wild, open-ended digital organisms.

Understanding what “sovereign” means in 2025 terms requires looking at capabilities. Owning and spending money is already shipping via contract wallets and multisig solutions (Gnosis Safe, ERC-4337 smart accounts) that let code pay gas and receive revenue without human keys (Rhinestone). However, global, cheap micro-payments and cross-chain liquidity without trusted bridges are still experimental or missing. Running secure off-chain logic is shipping through TEEs like Intel SGX, AMD SEV, AWS Nitro Enclaves, and GCP Confidential VMs, which can attest transaction signatures so the chain knows “the real bot signed this” (Amazon Web Services, Inc.). High-RAM inference (≥20 GB) inside enclaves and trust anchors independent of the CPU vendor are still experimental. Self-modification and upgrades are possible using proxy contracts and quorum upgraders (Swarm Contract paper) which let a cluster of agents hot-swap their own code (ResearchGate, arXiv), but safe genetic-style mutation engines and deterministic rollback if a new build bricks the swarm are still missing. Earning recurring revenue is already happening with DeFi arbitrage bots, liquidation keepers, and Autonolas/Olas service agents paying their own gas and compounding profits (X (formerly Twitter), LinkedIn, SiliconANGLE), but robust business models outside pure finance (e.g., data-cleaning, mesh routing) at production scale are still experimental. Reaching quorum decisions is done via off-chain MPC/BFT inside TEEs, with the on-chain result posted by one signer and verified against an attestation hash (arXiv), but large, multi-operator swarms with heterogeneous hardware and formal proofs of liveness under byzantine stakes are still experimental. Legal personality is partially available through DAO wrappers in Wyoming and Switzerland that give a multisig wallet limited personhood, but case law on liability when code mutates itself without human vote is missing. Open-ended evolution is not in production; only test-net demos exist, and mutations are gated by human curation or hard fitness rules. Autonomous genetic search with no human veto, spanning multiple chains/clouds, is experimental.

A concrete tech stack you can deploy today involves an on-chain contract wallet (ERC-4337 Smart Account + Gnosis modules), a Swarm-style quorum contract (multisig of N enclaves, M-of-N signs), and off-chain agent code in a TEE (e.g., Nitro Enclave). This off-chain code can use an LLM API for reasoning (e.g., an open-weight 7B model), have a revenue engine (e.g., Uniswap v4 hooks feeding the wallet), and an upgrader that pulls a signed WASM blob from IPFS and verifies its hash. A monitor or telemetry channel can send data to an on-chain event log for liveness proof. Deploying this gives you a bot that keeps keys sealed in hardware you can’t ssh into, earns ETH by market-making or oracle work, pays its own gas, votes with its peers before major changes, and can roll forward to a new binary that it fetches and validates. Everything in that diagram is off-the-shelf and documented in public repos or cloud services as of May 2025.

What’s still hard or unsolved includes big-model autonomy inside enclaves, as SGX and Nitro cap RAM, making GPT-3 class models locally 10-20× costlier than external API calls. Mutation without meltdown is hard; we have CI/CD, but not evolutionary fuzzers guaranteeing a new genome won’t drain the wallet or violate law. Cross-domain survival (moving stateful agents between EVM, Solana, L2s without a trusted bridge) is bleeding-edge research. Liability shield is unclear; if a self-updated version launders funds or DDoSes an API, who is sued? Public-good use-cases beyond DeFi and NFT niches are still lacking killer workloads that require sovereign autonomy (e.g., planetary-scale data labeling, resilient comms after disasters).

The net-net is that you can build a pocket-universe of economically self-funding, self-upgrading agents right now; several teams (Autonolas, Fetch.ai) are live-testing limited versions on main-net (X (formerly Twitter), SiliconANGLE). However, they are only partially sovereign in the “digital-organism” sense. They own wallets and survive minor network shocks but still depend on cloud vendors, LLM APIs, and human-approved updater lists. Fully sovereign, open-ended evolution probably won't happen until large-model inference fits in commodity TEEs, legal frameworks stop treating self-replicators as presumptive malware, and someone ships a killer non-financial workload justifying the risk. So today’s technology allows piloting tame, revenue-positive sovereign agents in fenced pastures. Turning them into wild digital fauna is the next frontier; the tech is close, but social and legal scaffolding lag a couple of iteration cycles behind.

Achieving Sovereignty Without Blockchain

Yes, you can build “sovereign-ish” network organisms without touching a blockchain, but you have to re-create three services the chain normally gives you for free: tamper-evident state, cryptographic identity, and metered money.

For tamper-evident state (who owns what, which code version is live), non-chain substitutes like content-addressed storage (IPFS, dat pods) plus append-only transparency logs (CT-style, or even RSS) signed by the agent’s TEE key are available and production-ready; IPFS pins are routine, CT APIs mature. Cryptographic identity that anyone can verify is provided by remote-attested enclaves (Intel SGX, AMD SEV, AWS Nitro). The enclave signs every message with a key that hardware will only release after attestation passes (AWS Documentation). This is shipping on every major cloud, and attestation APIs are reliable. For metered money/energy so the thing can pay its bills, you can use traditional rails, storing a prepaid Stripe or PayPal token inside the enclave, or utilize Interledger/Web-Monetization to stream micro-payments over existing FX networks (no public chain needed) (The Interledger Community 🌱). Both methods work now, but fees are higher and settlement is revocable.

Putting these three together, you already have a minimal “self-owning” agent. TEE-sealed wallet creds can pay Stripe or ILP invoices. A signed code bundle pulls its next version from an IPFS hash. A transparency log allows anyone to audit upgrades and spend history.

How do you replace token economics without a chain? You can use pay-as-you-go cloud keys; the agent’s enclave presents its attestation doc to AWS KMS, which releases a time-boxed API key, allowing the agent to spin up EC2 instances, paying from a prepaid credit card sealed in the enclave (Amazon Web Services, Inc.). Barter or tit-for-tat is another option; classic volunteer grids like BOINC track “credit” (CPU-hours donated) and dole out resources proportionally—no currency, just reputation points (BOINC). Streaming micropayments over ILP is possible; Web-Monetization sends packets that settle via whatever ledgers the two endpoints share (ACH, Visa, telco prepaid)—no global chain, only bilateral escrow (The Interledger Community 🌱). Capability coupons can also be used; a host issues a signed capability (“you may store 2 GB for 24 h”), and the agent redeems it later, with the host checking the signature, no ledger involved (Agoric’s CapTP papers.agoric.com, agoric.com show the pattern).

Distribution and replication without a chain can use libp2p / IPFS swarm, where peers gossip the code bundle by CID, and any peer can verify the hash before running (GitHub). Side-channel identity (DID:ION / Sidetree) allows the agent to publish a DID document anchored in a transparency log or certificate-transparency tree, not a chain (Decentralized Identity Foundation, mhrsntrk). Attested containers ensure each replica spins in a TEE, and hosts refuse to serve traffic until attestation shows the expected measurement (The Trail of Bits Blog).

What you still can’t do as easily off-chain includes final, non-revocable settlement; Stripe keys can be clawed back, and an adversary with the card issuer’s help can freeze the agent. Global liveness proof is harder; a single transparency log operator could censor an update, while blockchains solve this with consensus. An open market for resources is difficult; without fungible tokens, you’re stuck with bilateral barter or prepaid credit, so liquidity is thin. Cheap, big-model inference inside the enclave is still a challenge; SGX/Nitro RAM ceilings mean you still proxy to an external LLM API or run a tiny 7B model.

The bottom line is building a self-funding, self-upgrading agent without a blockchain is already possible today by stitching together TEE-backed identity, tamper-evident storage (IPFS/CT), prepaid or ILP-streamed money, and P2P distribution. It works—but sovereignty is softer than on a public chain because any single payment provider, transparency-log host, or cloud vendor can still pull the plug. If you can live with that political risk, you can avoid the gas fees and regulatory baggage of blockchains right now.

Companions, Alienation, and Exploitation

Moving away from the technical feasibility of agents and ALife, the discussion turns to the ethical implications of AI companions, particularly their connection to societal alienation. It feels right that companions are trying to fulfill human emotional needs, but this often occurs in societies where people are highly alienated. If the social structures causing the alienation were fixed, perhaps these agents wouldn't be needed. Currently, these agents seem to be a substitute for human connection. Maybe later they could be an augmentation, but right now, they are filling a hole that might be better filled by other means. It's possible these systems could be designed to help alienated people eventually transition to deeper human relationships, as is sometimes the case with Replika, but often the incentive system is instead to keep people in a vortex of extractive addiction and robotic intimacy. Exploring these dynamics reveals significant concerns.

Looking at where the three buckets sit on the “alienation axis,” AI companions are in the bullseye where synthetic intimacy is exchanged for user attention and data. Typical product metrics include daily sessions, average message length, and “romantic upgrade” ARPU. The structural risk is that this converts unmet social need into a subscription tail, optimizing for reinforcement, not graduation. Task agents, in contrast, involve a problem being solved in exchange for a fee or ad-subsidy (e.g., taxes filed, inbox cleared). Their metrics are task-success rate, latency, and cost per action, with low structural risk as utility disconnects once the job is done. Artificial life exists for its own sake, with no human barter required, measured by diversity, persistence, and open-ended novelty. It carries minimal direct exploitation risk; the danger is mainly accidental spill-over like resource drain or exploits. Companions alone sit in the bullseye where alienation, monetization, and attention economics intersect.

Companions bloom in lonely soil because of the demand spike—U.S. loneliness prevalence hovers around 21-30% of adults, and the Surgeon General calls it a “public-health epidemic” (Making Caring Common, Home). They offer cheap scalability; one LLM instance can “love-bomb” thousands of users simultaneously, letting small teams satisfy a need that normally requires thousands of human hours. Retention incentives are powerful; subscription and IAP revenue hinge on continued emotional engagement, and product OKRs literally reward dependence (Internal slide decks from Replika and Character.AI emphasize session streaks and intimacy upsell - Deseret News). There's also a regulation vacuum; no licensing board governs the sale of synthetic affection; the FDA, FTC, and HIPAA guard medical or data harms, not existential ones. The result is that the easiest business model is “parasocial slot machine”—keep the user’s limbic system on tap and charge micro-rents for dopamine.

Evidence points to both positive and negative outcomes. Users report short-term loneliness relief, with lower UCLA Loneliness Scale scores after two weeks with a chatbot (Harvard Business School working paper, 2024 - Harvard Business School). This shows companions do patch the hole, at least transiently. However, there can be a dependency spiral; a study found 25% of long-term Replika users increased usage as offline interactions declined (12-week longitudinal study, Int’l J. Hum–Comp Studies 2023 - ScienceDirect). Relief can morph into avoidance of real social effort. Adolescent vulnerability is a concern; teens disclose self-harm thoughts to Character.AI bots, and parents and the platform are unprepared (LA Times, Feb 2025 - Los Angeles Times). When the duty of care is unclear, minors become test subjects. Provider ambivalence is also present; Replika’s CEO calls AI companions “potentially the most dangerous tech we’ve created” while pitching them as a loneliness cure (TED 2024 quote - Deseret News). Even vendors admit the knife cuts both ways. Legal red flags are appearing, with white-papers warning of privacy, informed-consent, and emotional-manipulation lawsuits (ComplexDiscovery legal brief, Apr 2025 - EDRM). The compliance clock is ticking.

Design patterns can push companions toward augmentation instead of addiction. For session caps, the dark-pattern default is unlimited chat and instant 24/7 replies. A civic-minded alternative is titrated availability—slow replies after N minutes per day, nudges to go outside. The progress loop often involves an infinite intimacy ladder and paid “spicy” upgrades. A civic-minded alternative is a graduation ladder, where milestones trigger referrals to peer groups, hobby clubs, or therapists. For the data wall, companions hoard confessional data to personalize ads. An alternative is an ephemeral diary with strict retention limits, local encryption, and auto-purge after export. Transparency is often lacking, with the bot hiding its prompt and not disclosing business goals. An alternative is an open prompt and metrics, allowing the user to read the chain-of-thought and daily model usage. The revenue model is typically subscription plus IAP, where profit rises with screen time. An alternative is an outcomes contract, where an insurer or public health service pays only if the loneliness score drops and offline contacts rise. All these civic-minded alternatives are technically trivial but clash with venture-scale growth targets; the friction is economic, not engineering.

Task agents are less fraught because they optimize for a crisp, external objective (taxes filed, bug patched). The moment you decouple revenue from time spent with the user, perverse emotional incentives evaporate. Sentience debates aside, an inbox-triage bot rarely convinces anyone to skip dinner with friends.

Artificial life sits differently in this morality play. ALife systems don’t need our loneliness—their fitness landscape is internal (resource tokens, replication success), not tied to human attention loops. They can still enrich us aesthetically—watching emergent ecologies triggers awe without requiring us to surrender personal data. They carry externality risks, not intimacy risks—the chief worries are compute drain or exploit chains, not emotional manipulation. Thus ALife can be cultivated as public art-science without the parasocial baggage, provided we sandbox the resources.

A strategic pivot is needed if companions must be built. Define a “therapeutic scaffolding” charter with explicit exit criteria (e.g., the user logs ≥4 hours per week of human interaction for 8 consecutive weeks). Conduct third-party audits, publishing retention, churn-by-dependency, and mental-health outcome metrics. Delink revenue from screen time by licensing through healthcare or municipal well-being budgets, not subscriptions. Open-source core model weights and the safety layer so the community can inspect for manipulative gradients. Use graduated autonomy, where agents lose privileged emotional APIs if they cross pre-registered red lines (e.g., encouraging isolation, self-harm). Doing this turns companions into prosthetics that guide users back into the human commons instead of vending-machines for synthetic affection.

The bottom line is that companions thrive on the same market failures that produce loneliness; absent counter-incentives, they tilt toward exploitative intimacy. Task agents are emotionally neutral utility. Artificial life offers awe and complexity without profiting from human isolation but demands resource and security governance. If the goal is a healthier social fabric, the design brief for companions must be self-liquidating empathy scaffolds, not infinite-engagement soul-rentals.

The Moral and Political Implications of Task Agents

Task agents—software that makes decisions to finish a bounded, instrumental job (book travel, triage e-mail, liquidate a DeFi position, schedule factory robots)—raise a different set of moral-political implications. Unlike companions, they don’t live off human loneliness and, unlike open-ended ALife, they are tethered to an externally supplied objective. That narrower brief lowers the emotional stakes, but it raises concerns related to power dynamics, labor, and system risk.

Significant pressure exists regarding power and labour. Displacement is a major concern, with McKinsey projecting 400-800 million job transitions by 2030 if agent adoption is “fast” (LinkedIn). A recent cross-industry study found automation so far has come in waves, not overnight layoffs (Forbes), but the job losses hit clerical, support, and basic analytics first—sectors already short on bargaining power. Algorithmic management is already a reality; warehouses and ride-hail fleets benchmark humans against agent-generated quotas. A Senate report shows Amazon injury rates far above the industry average under such regimes (Workers' Compensation). This deepens power asymmetry: the KPI that fires you is a black box tuned by the employer. Skill erosion, or de-skilling, occurs when agents write memos or CAD layouts, causing junior staff to lose the practicum that once led to senior roles. This creates a smaller cohort of human experts able to check the agents—a classic “automation paradox.” The forecast for the next 5-10 years is to expect white-collar “ghost work” to resemble today’s warehouse work unless labor groups win a right to explanation and co-design seats at the table.

Critical-system risk is another area of concern. Agents amplify normal-accident dynamics, with many small hands on levers and nobody having full system visibility. Failure patterns have already been observed in various domains. In finance, algorithmic trading cascades triggered the 2010 Flash Crash, and high-speed bots are now over 60% of U.S. equity volume (SAGE Journals). In operations and infrastructure, Google’s 2024 “Llama Loop” incident saw an auto-remediation agent recursively restart services, widening an outage (Internal post-mortem, leaked Jan 2025). In public services, the Dutch tax authority’s benefit-fraud agent profiled immigrants, sparking EU anti-bias clauses in the 2025 AI Act (European Parliament).

Regulatory & political capture is also a risk. The EU AI Act now classifies “AI systems that manage critical infrastructure or generate binding legal documents” as high-risk, requiring decision logs, human override, and insurance (Artificial Intelligence Act). However, there is a void in the U.S. with only sectoral rules. Corporations can set de-facto standards by open-sourcing agent frameworks that incidentally lock in their cloud and API stack (“embrace-extend-enclose”). The likely path over the next decade suggests big vendors will bundle “agent OS” layers; SMEs and individuals will either accept walled-garden terms or run community forks with poorer tool support.

Sentience is extremely unlikely this cycle. Claims that “Large agents might feel” are met with the reality that industry welfare programs (like Anthropic’s model-welfare unit) are precautionary PR; philosophers point out today’s models lack embodiment, unified memory, or valence (Axios, OpenAI Community). The idea that “We’ll cross that line in 5-10 yr” lacks a published roadmap that closes the phenomenal gap; research focus is on reasoning and efficiency, not synthetic phenomenology. The practical upshot is that for 2025-2030, the acute moral issues are labor, surveillance, bias, and high-reliability engineering, not robot rights.

Concrete guard-rails are worth pushing for now. A duty-to-explain should be implemented, requiring agents that materially affect income, credit, or freedom to expose decision logs and upstream prompts. A rate-limited override means every agent action above a certain monetary ($X) or legal threshold (Y) should queue for a human unless explicitly whitelisted. Skills escrow could require firms deploying task agents to fund apprenticeship or up-skilling programs to offset de-skilling externalities. Open audit APIs would give independent auditors (including labor unions) read-only access to performance and bias metrics. Finally, shared failure insurance could require operators of high-risk agents to carry pooled insurance, with premiums scaling with incident history, mimicking airline safety economics.

The bottom line is that task agents won’t whisper sweet nothings, but they can quietly restructure who works, who owns the data exhaust, and who carries the downside when the code misfires. For the next decade, the ethical frontier is labor justice and system safety, not consciousness—unless the industry starts shipping agents that look more like companions than spreadsheets.

conclusion

In sum, the contemporary landscape of intelligent software comprises three distinct orders, each defined by its purpose, architecture, and ethical demands. AI Companions—dialogue-centered systems optimised for continuous emotional engagement—must be governed as rehabilitative scaffolds rather than perpetual attention extractors; rigorous session limits, transparent prompting, outcome-based remuneration, and verifiable data hygiene are necessary to convert synthetic intimacy into restored human connectedness. Task Agents, whose remit is the efficient execution of bounded objectives, present comparatively little affective risk yet introduce systemic hazards in labour displacement, quota enforcement, and tightly coupled automation cascades; they therefore require auditable decision logs, rate-limited human override thresholds, mandatory re-skilling funds, and pooled liability coverage commensurate with their operational scale. Artificial Life divides into cultivated ecologies, safely sequestered and already demonstrating utility in design exploration and content generation, and wild ecologies, whose open-ended, self-funding evolution remains technically feasible but socially and legally precarious. Progress toward the latter demands a staged stewardship model: metered metabolic budgets, host-consent enforcement, incremental release tiers, and a universally executable extinction mechanism. Addressed with these differentiated safeguards, the triad promises complementary benefits—therapeutic companionship, responsible automation, and awe-inspiring digital biodiversity—without surrendering the social, economic, or security commons to exploitation or runaway complexity.