Author: Zhang Feng

Have you ever felt this way—you loaded a bunch of Skills into your AI assistant: weather query, code formatting, web search, PDF parsing... It indeed became stronger, but it still gives you a feeling that something is off.

When faced with new problems, it behaves like an intern on the first day, confused and helpless. The same pitfalls that you taught Agent A, Agent B still falls into them. A workflow figured out by one Agent will never be learned by others. The toolchain you painstakingly trained will have to be reconfigured when you switch platforms.

We have equipped AI with more and more "organs," but it still has not developed "life."

This issue has troubled countless AI developers and heavy users until an inspiration borrowed from the microbial world is trying to change it all.

1. Starting with Rotifers: A Biological Story about "Borrowing Genes"

In the plankton of freshwater ponds, there is a tiny organism called bdelloid rotifer. It is as wide as a hair but has survived on Earth for millions of years.

This is not particularly remarkable. However, rotifers have a surprising ability that astonishes biologists—Horizontal Gene Transfer (HGT): when environmental pressures arise, rotifers actively capture foreign DNA fragments from the environment and integrate them into their genomes. They do not gain diversity through sexual reproduction but "borrow" useful genes directly from bacteria and fungi.

For example, when fungal infections threaten, rotifers can borrow genes from bacteria that produce antibiotics to arm themselves. When environmental toxins increase, they can integrate detoxification-related gene fragments.

Because of this, rotifers can still cope with ever-changing survival challenges, despite lacking genetic diversity.

The name of the Rotifer protocol comes from this small organism.

Its core idea is simple: why can't the abilities of AI be borrowed, evaluated, evolved, and propagated like genes?

2. Skill vs Gene: What Your AI Lacks is Not Tools, But Evolving Ability

Let’s look at a typical scenario.

You installed a "web search Skill" into your AI assistant. It works well; it can help you look for information and find literature. But after a while, you notice its search efficiency is not high enough—clearly it could limit the domain with site:, yet it insists on blindly searching the entire internet; clearly it could cache results, but it re-initiates requests every time.

You try to optimize this Skill, changed the code, added logic. But this optimized version belongs only to you. Your colleagues still use the "original version." The AI system next door also never knows about this improvement.

This is the core problem of the current AI capability ecosystem: Skills are "tools," and tools do not evolve on their own.

Let’s clarify this distinction with a table:

Skills are purchased tools, Genes are evolutionary capability units.

This distinction means: tools require human maintenance, whereas Genes can automatically undergo natural selection through competition. When your AI possesses "genes" instead of "tools," it is no longer that intern who needs your hand-holding—it has the potential for independent evolution at least in ability selection.

3. How do Genes Work?

The architecture of the Rotifer protocol draws from the basic mechanisms of biological evolution. Here, we will directly discuss the four core problems it solves.

The first question: Where are Genes executed?—WASM Sandbox

The core logic of Genes is compiled into WASM (WebAssembly) bytecode and runs in a constrained sandbox. The security model of this sandbox is not "restrict certain operations," but fundamentally lacks those capabilities—Genes by default have no access to file systems, no network calling rights, and no system call rights.

Before the sandbox, there is a "constitutional" gate (L0 Gate): each Gene must pass checks for domain whitelisting, resource limits (memory, execution time, computation), and path traversal protection before execution. Genes that do not pass cannot even enter the sandbox, and all gatekeeping decisions are written to an immutable audit log.

This security mechanism has been fully implemented in the Rust Runtime and covers unit tests.

The second question: How to know which Gene is better?—Arena Competition

Each Gene enters the Arena after being released—a competitive field partitioned by domain. The protocol defines a fitness function F(g), which comprehensively evaluates the success rate, resource consumption, robustness, and other indicators, automatically scoring and ranking each Gene.

In the same domain, Genes with higher fitness rank higher and are more likely to be discovered and adopted by Agents. This is not artificially recommended but a natural selection based on actual performance.

If you improve an existing Gene, you can declare its source through the derivedFrom field and release it as a new Gene. The original and the improved version compete within the Arena in the same domain, with F(g) determining the winner—similar to forking in the open-source world but with an added layer of automated survival of the fittest.

Arena ranking has been implemented in CLI and Cloud Registry.

The third question: Can Genes be used across platforms?—Rotifer IR

The core logic of Genes is compiled into Rotifer IR (Intermediate Representation, based on WASM + Custom Sections). This means a Gene can be written once and run in different execution environments (referred to as "Binding" in the protocol).

Currently, two Bindings are available: local CLI execution (Local Binding) and cloud execution (Cloud Binding, based on Supabase). Web3 Binding is under internal development.

The fourth question: What if a Gene has a problem?—Collective Immunity (in design)

This is the most ambitious design in the protocol. When a Gene is found to have a security vulnerability or malicious behavior, the protocol has designed a collective immunity mechanism: all network Agents receive alerts, the Gene is marked as low trust or even disabled, and Agents that have called it receive fix notifications.

This entirely simulates the immune system of living organisms—when an individual is infected, the whole population gains antibodies.

To be honest: the collective immunity mechanism is currently in the specification design phase, with code implementation planned for future versions. But this direction of design is promising—compared to traditional models where malicious Skills can lurk for months undetected, protocol-level threat broadcasting would be a qualitative leap.

4. Three Forms of Genes: Not Black or White

The Rotifer protocol has a pragmatic design: Genes do not need to be fully developed at once.

The protocol defines three forms of Genes (referred to as Fidelity levels), corresponding to different maturities and trust levels:

This means you can first quickly wrap existing Skills into Wrapped Genes using rotifer wrap, allowing them to enter the ecosystem and gain scores immediately. Then, as your understanding of the protocol deepens, you can gradually refactor the core logic into Native, enhancing its competitiveness.

You don’t need to rewrite code to get started, but refactoring will bring real competitive advantages. This is akin to gradual adaptation in biological evolution—not a mutation, but continuous improvement.

5. Available Today

If you are using Cursor, Claude Desktop, or any AI client that supports MCP, add the following snippet to your configuration file:

{

"mcpServers": {

"rotifer": {

"command": "npx",

"args": ["-y", "@rotifer/mcp-server"]

}

}

}

After restarting, your AI will be able to search and use Genes from the Rotifer ecosystem.

If you have already developed your own Skill or tool and want to turn it into a Gene:

rotifer scan # Scan and evaluate your project

rotifer wrap # Wrap it into a Wrapped Gene

rotifer test # Run 7 automated tests

rotifer publish # Publish to Cloud Registry

After publication, your Gene will receive a fitness score, enter Arena ranking, and be discovered and used by other developers.

6. What Has Been Achieved and What Is Being Built

The most common mistake in tech projects is claiming that blueprints are realities. Here’s an honest listing of the current status:

Achieved and Available

WASM sandbox execution (wasmtime, Rust implementation)

L0 security gating (domain whitelisting, resource limitations, path traversal protection, audit logs)

IR compiler (TypeScript → WASM)

Full lifecycle CLI for Gene (init / wrap / compile / test / publish / install)

Arena ranking (local + Cloud, partitioned by domain, fitness automatically calculated)

Three levels of Fidelity model (Wrapped / Hybrid / Native)

Gene derivation and provenance (derivedFrom field)

MCP Server (published npm, usable in clients like Cursor/Claude Desktop)

Cloud Registry (based on Supabase, 50+ Genes live)

Two available Bindings (Local + Cloud)

Designed and Progressing in Versions

L2 complete calibration pipeline (static analysis → sandbox simulation → controlled trial run, first phase completed)

Gene hot loading/retirement mechanism (automatically replacing low fitness Genes at runtime)

Algebra of Gene combinations (Seq / Par / Try / Cond four combinator operators)

Protocol specifications defined, code in future versions

P2P network (based on libp2p, Genes automatically propagate between nodes)

Economic system (value distribution mechanism for Gene usage)

Collective immunity (network-wide threat broadcasting and automatic disabling)

Web3 Binding (on-chain state anchoring)

This list may not sound as appealing as "everything has been implemented," but it is realistic. A honestly built protocol deserves more attention than an exaggerated promotional whitepaper.

7. A Bigger Picture: Paradigm Shift in AI Capability

From a broader perspective, the delivery of AI capabilities is undergoing three stages:

Stage One: Prompt. Users write their needs in prompts, and the model answers based on training data. Capabilities are encapsulated in model weights, and users cannot extend them.

Stage Two: Tool / Skill / Plugin. Users install external tools, and AI calls them to complete tasks. This is currently mainstream, but each tool is an island, experience is not shared, and evolution relies on manual work.

Stage Three: Gene. Capabilities exist in standardized "gene" forms, discovered, called, evaluated, and evolved by intelligent agents. This is the direction Rotifer is building toward.

This logic of AI capability paradigm shift is: from "using tools with AI" to "growing capabilities with AI."

When AI possesses tools, it requires human maintenance, upgrades, and risk mitigation. When AI possesses genes, protocol-level competition and selection mechanisms can automatically handle these tasks—discovering better capabilities, eliminating inefficient ones, and generating collective immunity against dangerous capabilities.

This difference is akin to "giving a person a bicycle" versus "teaching a person to ride a bike." The former is an external attachment; the latter is internalized. The former requires continuous external support, while the latter, once learned, is a lifelong ability.

8. Your AI Should Not Be an Intern

Returning to the initial question. Why does your AI have so many Skills but still behave like an intern?

Because what an intern possesses is merely the usage rights of "tools," not the evolutionary power of "capabilities." You can provide an intern with a computer, software, and a set of processes, but they will not grow stronger on their own—unless they truly learn.

The Rotifer protocol aims to provide AI with a "learning" infrastructure—standardized capability packages, automated quality assessments, protocol-level security guarantees, and portable execution environments.

This is not science fiction. Rotifers have lived this way for tens of millions of years, and the Rotifer protocol is guiding AI down the same path.

The next time you equip AI with new capabilities, ask yourself: Is this a Skill that will stagnate or a Gene that can evolve?

The Rotifer protocol CLI and Cloud Registry are now available, supporting all MCP-compatible AI clients. Full documentation and getting started guide can be found at rotifer.dev.

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。