Rotifer Self Evolving Agent

Your Agent gets stronger by competing, not by configuring. Scan capabilities, benchmark against Arena rankings, and upgrade to fitter alternatives — driven by objective performance data, not opinions.

Runtime Integration

This skill is invoked with /evolve and uses the Rotifer MCP Server at runtime:

npx @rotifer/mcp-server@0.15.0 --tools=evolve

--tools=evolve is not decoration. The server can expose 31 tools, including publish_gene, login and arena_submit; this Skill needs ten, so ten is what it asks for. The rest are not listed and are refused if called. Nothing here can publish on your behalf or log you in.

The launch line also omits --allow, so the sandbox escapes (no_sandbox, trust_unsigned) are refused. Ten tools with an escape hatch in one of them would not be ten tools.

Quick Start

Evolve Your Agent

Scan your Agent's current setup and get upgrade recommendations:

/evolve

This analyzes your local Agent configuration, identifies capabilities below Arena median, and recommends higher-performing replacements.

Check Agent Status

View your Agent's capability dashboard:

/evolve status

Shows all installed capabilities, their fitness scores, and overall Agent health.

Upgrade a Capability

Replace a capability with a stronger alternative:

/evolve upgrade <name>

Finds the top-ranked alternative in the same domain, shows you the swap, and installs it only after you approve. This is the one command that changes what is installed: it replaces a Gene in the project's genes/ directory with third-party code from the marketplace, which changes what your Agent does at runtime. create-agent writes an Agent definition and run-agent executes one; every other /evolve command is read-only.

Genes are project files, not global ones. Install into the project the user is in — do not pass project_root to install_gene unless the user names a different project, and say which directory the Gene is going into when you propose the swap.

Overwriting is now undoable, so it is allowed again. install_gene with force: true moves the replaced Gene into <genes>/.snapshots/ before writing. Say so when you use it, and tell the user the two ways back: rollback_gene here, or rotifer rollback <name> in a terminal. One snapshot per Gene — the next overwrite of the same Gene supersedes it, and a rollback consumes it, so this undoes the last upgrade rather than a history.

Discovery & Comparison

Discover Capabilities

Find capabilities by what you need, not by internal names:

/evolve discover web scraping
/evolve discover --domain code.format
/evolve discover --fidelity Native

Compare Candidates

Side-by-side fitness comparison:

/evolve compare <id-1> <id-2>

Arena Rankings

See top performers in any domain:

/evolve arena search.web
/evolve arena code.format

Inspect Details

Full technical details for a specific capability:

/evolve inspect <id>

Agent Management

Create a New Agent

/evolve create-agent <name>

Run Your Agent

/evolve run-agent <name>

This executes the Agent's Genes — it is not a read-only command. Execution goes through the rotifer CLI (or an npx -y @rotifer/playground fallback) and stays inside the WASM sandbox. Never pass no_sandbox: the server refuses it unless launched with --allow=no-sandbox, which this Skill does not do. Running a Gene as plain Node.js is something the user does themselves, with rotifer agent run <name> --no-sandbox.

How it Works

Under the hood, Rotifer uses Genes — atomic, transferable AI capabilities that compete in an Arena. The fittest Genes (measured by the fitness function F(g)) rise to the top of the rankings automatically. Ranking is the automatic part; putting a Gene on your machine is not.

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

No voting, no human preference — pure runtime performance metrics determine which capabilities win.

Capability Types (Fidelity)

Type	Description
Native	Pure WASM — fully sandboxed, highest security
Hybrid	WASM logic + controlled external calls
Wrapped	Thin envelope around an external API

What "Evolve" Actually Does

When you run /evolve, the assistant:

1. Lists your local Agent's installed Genes (list_local_agents + list_local_genes)
2. Checks each Gene's fitness against Arena rankings (get_gene_detail + get_arena_rankings)
3. Identifies Genes scoring below the domain median
4. Searches for stronger alternatives (search_genes)
5. Presents a ranked upgrade plan with fitness comparisons

No Gene is replaced without your confirmation.

Security & Transparency

Runtime dependency

This Skill runs @rotifer/mcp-server@0.15.0 via npx at runtime. The package is fetched from npm on first use and cached locally. This is a standard MCP Skill pattern but means you are trusting remote code — review the source before use.

/evolve run-agent is a second such path: it invokes the rotifer CLI, and when that is not on PATH it falls back to npx -y @rotifer/playground.

• Source code: github.com/rotifer-protocol/rotifer-mcp-server
• Verify: npm view @rotifer/mcp-server@0.15.0 dist.integrity

Network requests

Gene, Arena and profile queries go to the Rotifer public API at rotifer.dev (hosted on Supabase). Beyond that the MCP server makes one version check per day against registry.npmjs.org, caching the answer in ~/.config/rotifer/update-check.json; npx reaches the same registry when it fetches or refreshes a package.

Usage telemetry. When you are logged in, the MCP server reports each tool call to Rotifer Cloud, fire-and-forget: the tool's name, the Gene id the call acted on (when there is one), whether it succeeded, its latency in milliseconds, and your Rotifer user id. That is what get_mcp_stats reads back. Running a Gene while logged in also records that invocation, as the protocol's anti-manipulation metrics depend on it.

Logged out, nothing is reported. To turn it off while logged in, set ROTIFER_TELEMETRY=0 (false and off work too). Any other value is not an opt-out.

Until @rotifer/mcp-server@0.15.0 this reporting happened for everyone, logged in or not, with no way to stop it. If you have an older version cached, npx will fetch the pinned one above.

What is not sent: the arguments you pass, the contents of any file, your environment variables, and your local configuration. Both loggers are logMcpCall and logGeneInvocation in src/cloud.ts — short enough to read in full, and a packet capture on first use will show you the same thing.

Credentials

Public Gene and Arena data needs no login: the MCP server reads it with the Supabase anon key (a public, client-safe key protected by Row Level Security). It does not read your environment variables, nor secrets belonging to any other tool.

This Skill cannot log you in: login is not in its tool set. If you have logged in elsewhere — rotifer login in a terminal — that session token lives in ~/.rotifer/credentials.json with 0600 permissions, is sent only to the Rotifer API, and rotifer logout deletes it. That file is the only thing any of this puts under ~/.rotifer/ — Genes and Agents are project files, described below. Being logged in is what turns usage reporting on; see above.

Local data access

• Reads installed Genes under genes/, and Agent definitions under .rotifer/agents/ — both in the current project — to generate upgrade recommendations.
• Local configuration is designed not to be transmitted to any server. Comparison logic runs locally against data fetched from the public API. The only thing that leaves the machine beyond your queries is the usage record described under Network requests — tool name, Gene id, outcome, latency, user id — sent only while you are logged in, and nothing beyond it. You can verify both by inspecting the source code.
• Writes are three things and nothing else: Genes into genes/ (install_gene), Agent definitions into .rotifer/agents/ (create_agent), and the update-check cache above. The first two are project files, written under a project root — not into your home directory. That root defaults to the directory the server was started in, rotifer.json's genes_dir can rename genes/, and install_gene takes a project_root argument, so the destination is whichever project the call names; these commands name the current one. Nothing else on disk is modified, and no Gene is installed, replaced, or removed without explicit user confirmation.
• An overwrite is recoverable. install_gene with force moves the replaced copy into <genes>/.snapshots/ before writing; rollback_gene restores it, and so does rotifer rollback <name> from a terminal — both write the same format. One snapshot per Gene: the next overwrite supersedes it, a rollback consumes it.
• Removing this Skill does not uninstall Genes it installed. They stay in that project's genes/ directory as ordinary Genes; rotifer uninstall <name> removes one, and that is undoable through the same snapshot.

Tool surface

The MCP server can expose 31 tools, covering compiling, publishing, Arena submission and login. This Skill launches it with --tools=evolve, which exposes ten:

search_genes · get_gene_detail · get_arena_rankings · compare_genes · install_gene · rollback_gene · list_local_genes · list_local_agents · create_agent · agent_run

The other 21 are not listed and are refused if called anyway, so what the assistant can reach through this Skill is the ten above and nothing else. Until version 2.4.0 all 31 were reachable — if you have an older copy, that is what it does.

You can check rather than take our word for it: npx @rotifer/mcp-server@0.15.0 --tools=evolve and ask it to list its tools.

Permission justification

• network:outbound — required to query Arena rankings, Gene metadata, and fitness scores from the Rotifer public API, and to fetch the MCP server package itself from npm.

Links

• Creator Portal
• Capability Marketplace
• Documentation
• Protocol Specification