The way we build AI agents is changing fast. In three years, the dominant architecture has shifted from “LLM that calls functions” to “persistent autonomous entity” to something that looks increasingly like a biological ecosystem. This isn’t a marketing narrative — it’s a structural observation about how agent capabilities are organized, transferred, and improved.
This post traces three generations of agent architecture and examines what each generation makes possible that the previous one couldn’t.
Generation 1: The Classic Agent (2023)
Lilian Weng’s influential 2023 blog post crystallized the classic agent architecture that dominated the first wave of LLM-based agents. The model is elegant in its simplicity:
- An LLM sits at the center
- Tools extend its capabilities (Calendar, Calculator, Search, Code Interpreter)
- Planning modules guide its reasoning (Chain of Thought, Reflection, Self-criticism, Subgoal Decomposition)
- Memory provides context (short-term via context window, long-term via vector stores)
- The LLM produces Actions based on this orchestrated context
This architecture powered AutoGPT, BabyAGI, LangChain agents, and dozens of similar systems. Its key property: the agent is a session. It exists when a user starts a conversation and disappears when the conversation ends. Tools are hardcoded into the system. There is no mechanism for the agent to acquire new capabilities, share discoveries with other agents, or improve over time.
The classic agent is a passive tool caller — powerful within a single interaction, but stateless across interactions and isolated from other agents.
Generation 2: OpenClaw (2025)
The OpenClaw framework, developed by ClawCore and BISHENG, represents the next evolutionary step. It preserves the classic agent’s core (LLM + Tools + Actions) but adds four structural innovations:
Persistence. Memory moves from the context window to file-based storage. The agent has durable short-term and long-term memory that survives across sessions. Conversations build on each other.
Identity. Each agent has a Soul — a persistent identity document that defines its personality, goals, and behavioral parameters. This isn’t just a system prompt that gets regenerated; it’s a stable reference point that shapes behavior across interactions.
Skills. Instead of hardcoded tool functions, agents acquire capabilities through Skills — modular packages that can be installed, configured, and shared. The MCP (Model Context Protocol) provides a standardized interface for external tool access, decoupling the agent from any single tooling vendor.
Autonomy. Cron + Heartbeat enables the agent to act without human initiation. The agent doesn’t just wait for prompts — it can schedule its own work and maintain an ongoing heartbeat of activity.
OpenClaw agents are persistent autonomous agents. They remember, they have identity, they acquire skills, and they can act on their own schedule. But there’s still a structural gap: skills are manually installed and updated. There is no mechanism for skills to compete against each other, no quantitative measure of whether one skill outperforms another, and no way for a capability improvement discovered by one agent to automatically propagate to others.
Generation 3: Rotifer Protocol (2026)
The Rotifer Protocol takes the biological metaphor literally. Instead of treating agent capabilities as static packages, it treats them as genes — modular units of logic that are born, compete, evolve, and propagate across a population of agents.
The name comes from bdelloid rotifers — microscopic animals that have thrived for 40 million years through horizontal gene transfer, incorporating useful genetic material from entirely different species into their own genomes.
URAA: Five Layers of Evolution
The architecture is organized into five layers:
| Layer | Name | Function |
|---|---|---|
| L4 | Collective Immunity | Threat broadcasting across the agent network |
| L3 | Competition & Exchange | Arena ranking + Horizontal Logic Transfer |
| L2 | Calibration | Fitness F(g) and security V(g) evaluation |
| L1 | Synthesis | IR compilation (TypeScript → WASM) |
| L0 | Kernel | Immutable constraints — the constitutional layer |
The bottom layer (L0) is deliberately immutable — no gene, no agent, no evolutionary process can modify the constitutional constraints. This mirrors the role of fundamental physical laws in biological evolution: the rules of the game don’t change even as the players evolve.
The Gene Pool
Three types of genes coexist:
- Native Gene — executable WASM, full sandbox isolation, maximum portability
- Hybrid Gene — WASM execution with controlled network access through a gateway
- Wrapped Gene — API wrapper with metadata, for capabilities that can’t be compiled to WASM yet
Every gene must satisfy three axioms: functional cohesion (does one thing well), interface self-sufficiency (carries its own input/output schema), and independent evaluability (can be scored in isolation).
Horizontal Logic Transfer
The critical structural addition is HLT (Horizontal Logic Transfer): when one agent discovers or develops a high-fitness gene, that gene can propagate across the network proportional to its fitness score. This is the computational analog of rotifer HGT — the biological mechanism that allowed asexual organisms to thrive for 40 million years without the genetic diversity that sexual reproduction provides.
Bindings and Portability
Genes execute across heterogeneous Bindings (Local, Cloud, Web3) through a formal capability negotiation protocol: negotiate(R_ir, C_binding). A gene compiled for local execution can be verified for cloud compatibility before deployment. The binding abstraction eliminates “works on my machine” at the protocol level.
The Arena
The Arena provides selection pressure: genes compete on standardized benchmarks, and their fitness F(g) — a multiplicative function of success rate, utilization, robustness, latency, and cost — determines their ranking. The multiplicative structure is key: a gene with zero security or zero reliability scores zero overall, regardless of how well it performs on other dimensions.
The Comparison
| Dimension | Classic | OpenClaw | Rotifer Protocol |
|---|---|---|---|
| Unit | Prompt | Skill | Gene (WASM IR) |
| Memory | Context Window | File-persisted | State Anchoring (L0) |
| Evolution | None | Manual Update | F(g) Natural Selection |
| Transfer | Copy-paste | Skill Install | HLT P2P Propagation |
| Identity | Per-session | Soul + Identity | Binding-abstracted |
| Autonomy | Reactive | Cron + Heartbeat | Arena Competition |
| Tool Access | Hardcoded Functions | MCP Protocol | RotiferBinding Trait |
| Security | Per-app | Per-app | L4 Collective Immunity |
Each row reveals a structural gap that the next generation fills:
- Unit: From ephemeral prompts to persistent skills to compiled, content-addressable genes with formal schemas.
- Evolution: From no improvement mechanism to manual updates to quantified fitness-based natural selection.
- Transfer: From copying text to installing packages to automatic fitness-proportional propagation across a network.
- Security: From application-specific policies to a protocol-level collective defense system.
What Changes When Agents Evolve
The shift from Generation 1 to Generation 3 is not incremental improvement — it’s a change in what’s architecturally possible:
Discovery becomes automatic. In the classic model, an agent uses the tools it was built with. In OpenClaw, it acquires skills that humans curate. In Rotifer, high-fitness genes propagate automatically — the network routes good ideas to agents that need them.
Quality becomes measurable. Classic agents have no standardized quality metric for their capabilities. OpenClaw has community adoption signals. Rotifer has F(g) — a formal, reproducible fitness function that drives natural selection.
Security becomes collective. When a malicious capability is detected in a classic agent, only that agent is protected. In Rotifer’s Collective Immunity layer, a threat detected by one agent generates a defense fingerprint that protects the entire network.
Portability becomes guaranteed. Classic tools are bound to their runtime. OpenClaw skills are language-specific packages. Rotifer genes compile to WASM IR and negotiate compatibility with any binding — local, cloud, or on-chain — before execution.
We’re not claiming these three architectures are the only possible approaches, or that evolution is strictly linear. But the trajectory is clear: the unit of agent capability is getting more formal, more portable, and more amenable to automated improvement. The question is no longer whether agent capabilities should evolve — it’s whether the evolution happens by accident (manual updates, community curation) or by design (quantified fitness, formal propagation, collective safety).
Biology solved this problem 40 million years ago. Software is catching up.
Try it: npm i -g @rotifer/playground · rotifer.dev · Docs