Frequently Asked Questions

Rotifer Protocol is an open-source evolution framework for AI agents. Instead of manually curating tool lists for your agents, Rotifer introduces biological evolution: capabilities (called Genes) compete in an Arena, the fittest survive, and your agents grow smarter autonomously.

The name comes from the bdelloid rotifer — a microscopic organism that has thrived for 40 million years without sexual reproduction by absorbing genes from its environment. Rotifer Protocol applies the same principle to software.

Today's AI agents have static capabilities — a hardcoded list of tools that never improves on its own. If Tool A is terrible and Tool B is great, the agent has no way to know. There's no competition, no selection, no evolution.

Rotifer fixes this by introducing:

• Arena competition — same-domain Genes fight head-to-head on fitness metrics
• Natural selection — the fittest Genes survive, the rest are eliminated
• Autonomous improvement — agents automatically upgrade their genome over time

Relationship: Complementary — MCP standardizes how agents call tools; Rotifer standardizes how tools evolve.

Synergy: MCP Tools can be upgraded to Rotifer Genes with one command (rotifer wrap --from-skill), gaining quality ranking, security scoring, and autonomous evolution. MCP is Rotifer's most important upstream ecosystem.

Relationship: Direct competitor — both build an "evolution layer" on top of MCP/Skills, but with fundamentally different definitions of what "evolution" means.

Core architectural distinction: EvoMap treats Genes as strategy documents — standardized records of how a problem was solved, shared for other agents to replicate. Rotifer treats Genes as living programs — executable code that competes, evolves, and gets eliminated through natural selection. The same word "Gene", two entirely different things.

Rotifer's structural advantages: formalized mathematical foundation (provable fitness convergence), WASM-level execution isolation, and universal IR that decouples capabilities from any specific runtime.

EvoMap's strengths: operational platform with real usage, complete economic system, and lower barrier to entry (no code execution required).

Relationship: Complementary — these are orchestration frameworks (how multiple agents collaborate); Rotifer is a capability protocol (how individual capabilities evolve).

Synergy: These frameworks can serve as upstream users — orchestrate multiple agents with AutoGen/CrewAI, while each agent's capabilities are powered by Rotifer Genes that evolve autonomously.

Relationship: Orthogonal — A2A handles agent-to-agent communication; Rotifer handles capability evolution. They operate at entirely different protocol layers.

Synergy: Agents on the A2A network can use Rotifer Genes as their capability modules. Zero overlap, full compatibility.

Yes. The engine is Apache 2.0 + Rotifer Safety Clause, the specification is CC BY-SA 4.0.

• Playground (CLI + Runtime)
• Protocol Specification
• Papers & Whitepapers

v0.8.5 — the current public release line. It consolidates the shipped v0.8.x surface across the CLI, MCP Server, VS Code extension, and rotifer.dev, including the Skill→Gene migration path, CLI UX refresh, and version/update alignment work. Versions v0.8.2 through v0.8.4 were reserved internal iteration numbers rather than separate public releases. See the Roadmap for what's next.

A Gene is the atomic capability unit in Rotifer. Think of it as a "living plugin" that can:

• Compete in the Arena against other Genes in the same domain
• Evolve through mutation and selection pressure
• Propagate to other agents via horizontal gene transfer
• Be eliminated when its fitness declines

Every Gene has a typed interface (inputSchema / outputSchema), a unique identity (content hash), and runs inside a WASM sandbox.

Similarities: Both are modular, composable, reusable AI agent capability units. Both define input/output schemas.

Key differences:

In short: Skill is the degenerate special case of Gene — turn off all "life characteristics" and you get a Skill.

The Arena is where Genes compete. Same-domain Genes are evaluated head-to-head on four fitness dimensions:

• Correctness (S_r) — does it produce the right output?
• Utilization (C_util) — how much real-world usage does it get?
• Robustness (R_rob) — does it handle edge cases gracefully?
• Efficiency — latency and resource cost

Evaluation is automated by the protocol — no human judges. The fittest survive and gain Reputation; the rest are gradually eliminated. It's biological natural selection applied to software capabilities.

A Binding is the execution environment for Genes — the protocol doesn't care where a Gene runs, only that it conforms to the interface standard. There are currently three Bindings: Local (CLI), Cloud (Supabase), and Web3 (on-chain).

AI IDEs (Cursor, Claude Code, Windsurf, etc.) are a special type of Local Binding that plays two roles simultaneously:

• Growth Environment — Agents express Genes, execute tasks, and accumulate data here
• Gene Incubator — creators build, debug, and test new Genes here, then publish them to the Arena

Not every Binding is an incubator (Cloud Binding only runs, it doesn't create), but IDE Bindings naturally serve both roles — they are where Genes are born and where they run.

Every Gene has a fidelity level that determines how it executes:

• Native — has an executable express() function, compiles to WASM, runs in a sandbox with no network access. Best for deterministic computation (grammar checking, data transforms, scoring).
• Hybrid — runs in a sandbox but can make controlled network calls to explicitly declared allowedDomains. Best for capabilities that need external APIs (LLM calls, search APIs).
• Wrapped — lightweight metadata wrapper, serves as an AI prompt template for tasks requiring LLM reasoning (creative writing, architecture design).

All three participate in the ecosystem. Native and Hybrid Genes compete in full Arena fitness evaluations; Wrapped Genes are ranked on usage and stability only.

URAA (Universal Rotifer Autonomous Architecture) separates the protocol into five immutable layers, each modeled after a biological system:

Each layer communicates only through standardized interfaces. This is what makes Rotifer a protocol, not just a framework — the layered architecture is environment-independent and carries formal safety guarantees across all bindings.

Rotifer provides a formal algebraic system for composing simple genes into complex behaviors — with type safety, error propagation, and fitness inheritance:

This is a key differentiator from tool registries: compositions are type-checked at compile time, incompatible schemas produce errors before execution, and composed genes inherit fitness from their components. The Arena evaluates compositions as a whole.

Genes compile to Rotifer IR — an intermediate representation built on WASM with protocol-specific custom sections (phenotype, constraints, metering). This IR is to genes what LLVM IR is to programs:

• Write once — develop a gene in any environment (your local IDE, cloud, etc.)
• Compile once — rotifer compile produces a universal IR artifact
• Run anywhere — the same IR executes on Local, Cloud, Web3, or Edge bindings

The critical property is the Constitutional Unity Invariant: any L0 safety constraint declared in any binding is preserved through compilation, transmission, and re-compilation. No binding can weaken a constitutional constraint. This is what makes cross-binding portability safe, not just convenient.

The fitness function uses a multiplicative model, not a weighted average:

F(g) = [S_r · ln(1 + C_util) · (1 + R_rob)] / [L · Resource_Cost]

This means any single zero-valued factor drives the entire score to zero. A gene with 0% success rate always scores zero — no matter how fast or efficient it is. This prevents weak dimensions from being masked by strong ones.

This is distinct from the Gene Reputation Score R(g), which uses a weighted average — see the dedicated question below.

Three levels of abstraction, each building on the previous:

In practice: you create Genes individually (rotifer init), then assemble them into an Agent (rotifer agent create --genes a b c). The Genome is defined implicitly — you don't manage it as a separate file. Genes are published independently; Agents are local compositions.

Gene reputation uses phase-based dynamic weights:

R(g) = W_arena × Arena + W_usage × Usage + W_stability × Stability

• W0 Cold-start — 0.70 Arena + 0.05 Usage + 0.25 Stability
• W1 Normal — 0.60 Arena + 0.20 Usage + 0.20 Stability
• W2 Mature — 0.50 Arena + 0.30 Usage + 0.20 Stability

This is a different metric from fitness F(g) (multiplicative model where any zero-valued factor drives the score to zero). Reputation measures "long-term trustworthiness"; fitness measures "how good right now".

Decision framework — if 3+ are "yes", go Native:

High-value Native domains (far beyond current catalog):

Keep as Wrapped (these rely on LLM reasoning, not deterministic algorithms):

• Creative writing, brainstorming, architecture design, product management, strategic planning
• Anything where "good" is subjective and human judgment defines quality

A Gene is an executable function, not static data. Every Gene must have an express(input) function — it takes input, runs logic, and returns structured output.

// ❌ This is NOT a Gene — it's just data
{ name: "anchoring-effect", template: "Was $2999, now only $99" }

// ✅ This IS a Gene — it has input, processing, output
export async function express(input) {
  const analysis = analyzeHooks(input.text);
  return { hooks: analysis.detected, score: analysis.effectiveness };
}

If your "capability" is just a text template, it should be a data file inside a Gene (e.g. patterns.json), consumed by the express() function as a rule engine input.

Follow the Gene axiom of functional cohesion — one Gene solves one atomic problem.

Rule of thumb: if two "capabilities" have identical input/output schemas, they are not two Genes — they're two strategy parameters of the same Gene.

// ❌ 50 templates = 50 Genes (violates functional cohesion)
// ✅ 50 templates = 1 Gene + 50 rule data entries

Typical split: 5–6 functionally distinct Genes (analyze, score, generate, rewrite, recommend, filter) are more valuable than 50 structurally identical ones.

Quick rule: No network → Native. Needs network → Hybrid. Just get it running → Wrapped. See the Hybrid Gene Development Guide for details.

One command:

rotifer arena submit my-gene

Once submitted, your Gene competes head-to-head against other Genes in the same domain on fitness metrics. Use rotifer arena list to view rankings and rotifer arena watch for real-time monitoring. See Arena Commands for details.

Migration is a progressive enhancement, not a rewrite. Two commands handle everything:

rotifer scan --skills       # Scan existing Skills, assess migration feasibility
rotifer wrap --from-skill   # Auto-convert to Gene in one command

Your core business logic stays the same:

• inputSchema / outputSchema maps directly to Gene Phenotype
• Workflow / Chain maps to Genome DataFlowGraph

See the Skill Import Guide for details.

Option A — Terminal:

npm install -g @rotifer/playground
rotifer init my-project
cd my-project
rotifer hello

Want to preview curated templates first? Run rotifer hello --list-templates.

Option B — Paste this into your AI IDE:

See the Getting Started guide for a full walkthrough.

Each card contains a ready-to-paste prompt. Copy it, paste into your IDE's chat, and the AI handles the rest. Replace grammar-checker with any name from the catalog.

International IDEs

China IDEs

Yes, completely free and open source. The CLI, runtime, and all 68+ Genes in the catalog are free to use. There are no usage fees, no API keys required for local execution, and no premium tiers.

The only costs are ones you bring yourself — if a Hybrid Gene calls a paid external API (like an LLM provider), you pay that provider directly. Rotifer itself charges nothing.

Yes — safety is enforced at the protocol level, not left to individual implementations:

• WASM Sandbox — Native Genes execute inside a WebAssembly sandbox with no filesystem, network, or system access by default
• L0 Immutable Constraints — security rules that no layer of the protocol can override or weaken
• Resource Metering — CPU and memory limits prevent runaway execution
• Hybrid Allowlists — Genes that need network access must explicitly declare allowedDomains; all other network calls are blocked

Every Gene also has a security score V(g) computed through static analysis and sandbox testing before it enters the Arena.

Three ways to discover Genes:

• Gene Catalog — browse all published Genes with filtering by domain, fidelity, and reputation
• CLI — run rotifer search <keyword> to find Genes from the terminal
• Gene Marketplace — visual marketplace with detailed Gene profiles and Arena rankings

• GitHub Issues — bug reports, feature requests, and technical questions
• Creator FAQ — detailed technical answers for CLI usage, Gene development, and troubleshooting
• Discord — real-time community chat