What makes rotifer-agent notable?

985 downloads. Trust evidence available

How should rotifer-agent be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

rotifer-agent

Build a Rotifer Agent from Genes — decompose intent into capability units, pick Genes by Arena F(g), compose a Rotifer Genome, create the Agent and test it. Use when the user is working with Rotifer specifically: "Rotifer Agent", "compose Genes", "Rotifer Genome", "Gene composition", "rotifer agent create". Do NOT use for general agent frameworks, or when the words Seq / Par / Cond / Try appear as ordinary programming terms — in Rotifer those name Genome composition strategies, and this Skill applies only when the user is composing Rotifer Genes.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

985

Updated

Oct 11, 2026

Version

1.2.1

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 985 downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 985 downloadsadoption · observed Oct 11, 2026
Latest release: 1.2.1release · observed Aug 17, 2026
Handshake status: UNKNOWNsecurity

What changed

Newest first. Only changes that point at a source are listed.

Release 1.2.1release
rotifer-agent 1.2.1 - Updated documentation and metadata, including changes to README.md and clawhub.json. - No functional changes to the skill logic or behavior. - Improvements focus on documentation clarity and workflow instructions.
Observed Aug 17, 2026 · source

Install and run

Setup complexity: low.

clawhub skill install s174dvd7sg66gw86h4t3c8575d83g51m:rotifer-agent

Install using `clawhub skill install s174dvd7sg66gw86h4t3c8575d83g51m:rotifer-agent` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/xiaoba-dev/rotifer-agent before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-xiaoba-dev-rotifer-agent/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

124,957 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: rotifer-agent
description: >-
  Build a Rotifer Agent from Genes — decompose intent into capability units, pick Genes by
  Arena F(g), compose a Rotifer Genome, create the Agent and test it.
  Use when the user is working with Rotifer specifically: "Rotifer Agent", "compose Genes",
  "Rotifer Genome", "Gene composition", "rotifer agent create".
  Do NOT use for general agent frameworks, or when the words Seq / Par / Cond / Try appear as
  ordinary programming terms — in Rotifer those name Genome composition strategies, and this
  Skill applies only when the user is composing Rotifer Genes.
---

# Rotifer Agent — From Genes to Agents

Decompose user intent into capability units, select Genes from the ecosystem, compose a Genome, create and validate an Agent.

## Prerequisites

This Skill requires the Rotifer CLI:

```bash
npx @rotifer/playground --version
rotifer doctor
```

`rotifer doctor` checks the TypeScript→WASM toolchain. Composing an Agent from
Native Genes means compiling them, and without esbuild and javy that step fails
with an error that reads like a code problem.

Or use the MCP Server for IDE integration:

```json
{
  "mcpServers": {
    "rotifer": {
      "command": "npx",
      "args": ["@rotifer/mcp-server"]
    }
  }
}
```

---

**Hierarchy**: Gene (atomic logic) → Genome (composition) → Agent (runnable entity)

---

## Phase 1: Intent Decomposition

Break the user's goal into independent capability units (each maps to a Gene).

**Steps**:

1. Confirm the Agent's input and expected output with the user
2. Decompose the task into 2–6 capability units, each satisfying the Gene three axioms (functional cohesion, self-sufficient interface, independently evaluable)
3. Label each unit with a domain (e.g. `content.grammar`, `security.audit`)
4. Confirm the decomposition with the user before proceeding to Phase 2

**Output format**:

| # | Capability unit | Domain | Input | Output |
|---|----------------|--------|-------|--------|
| 1 | Grammar check | content.grammar | text | issues[], score |
| 2 | Readability analysis | content.readability | text | grade, suggestions[] |

---

## Phase 2: Gene Selection

Match existing Genes to each capability unit.

```bash
rotifer list                                  # what is already in this workspace
rotifer arena list --domain <domain>          # ranked by F(g) within one domain
rotifer search <capability> --domain <domain> # the Cloud registry — everyone else's Genes
```

The three answer different questions, and skipping the third is how a Genome
ends up built only from what happened to be installed already.

**Selection priority**:

| Priority | Source | Command |
|----------|--------|---------|
| 1 | Local Gene with highest Arena rank | `rotifer arena list --domain <d>` |
| 2 | Cloud Registry | `rotifer search <capability>` → `rotifer info <ref>` → `rotifer install <ref>` |
| 3 | Doesn't exist, needs creation | Proceed to Phase 3 |

Before committing a candidate to the Genome, run

README.md

# Rotifer Agent

> From intent to running Agent in seven steps.

Build a Rotifer Agent by composing [Genes](https://rotifer.dev/docs) — the atomic, fitness-evaluable capability units of [Rotifer Protocol](https://rotifer.dev).

**Not a general agent framework.** This composes Rotifer Genes into a Rotifer
Genome, through the Rotifer CLI. It does not build agents for LangChain, CrewAI
or anything else, and the words Seq / Par / Cond / Try name Genome composition
strategies here — seeing them in ordinary code is not a reason to invoke it.

## What It Does

Say what the Agent should do **in Rotifer terms**, and this Skill handles the architecture:

| Say this | It does this |
|----------|-------------|
| "Build a Rotifer Agent that checks document quality" | Decomposes into grammar + readability + tone Genes, recommends Par composition |
| "Compose Rotifer Genes into a code review Agent" | Selects security-auditor + code-complexity + docs-writer, designs a Seq(Par, …) Genome |
| "Make a Rotifer Genome for search and summarize" | Picks web-search → summarizer → formatter, wires up Seq |

## The Seven Phases

1. **Intent decomposition** — break the goal into 2-6 capability units
2. **Gene selection** — find the fittest Gene for each unit from Arena rankings
3. **Gap filling** — create missing Genes (route to gene → dev module)
4. **Genome composition** — choose Seq / Par / Cond / Try / TryPool
5. **Agent creation** — `rotifer agent create`
6. **Test run** — `rotifer agent run` with validation checklist
7. **Iteration** — swap underperforming Genes, tune composition

## Composition Strategies

| Strategy | Semantics | Use when |
|----------|-----------|----------|
| **Seq(A, B, C)** | Pipeline: A → B → C | Output of one feeds the next |
| **Par(A, B)** | Parallel: run simultaneously | Independent tasks, merge results |
| **Cond(p, A, B)** | Branch: if p then A else B | Input determines the path |
| **Try(A, B)** | Fallback: A fails → B | Primary path unreliable |
| **TryPool(A, B, C)** | Race: all try, first wins | Multiple equivalent implementations |

## Quick Start

```
Build a Rotifer Agent that checks document quality — grammar, readability, and tone
```

The Skill decomposes the intent, finds top-ranked Genes, and creates the Agent.

## What this Skill does on your machine

It has no code of its own — it tells your assistant which `rotifer` commands to
run. That is what its manifest's process-execution, filesystem and network
permissions are for: the CLI acting, not this Skill.

| | |
|---|---|
| **Runs** | The `rotifer` CLI (`@rotifer/playground`), fetched from npm if not installed. |
| **Reads** | Genes and Agent definitions in the current project. |
| **Writes** | Genes into the project's `genes/`, Agent definitions into `.rotifer/agents/`. Nothing outside the project. |
| **Sends** | Registry and Arena queries to the public Rotifer API. Your code is not uploaded unless you run `rotifer publish` yourself. |

Commands that install, publish or ov

_meta.json

{
  "ownerId": "kn7ec5m4jmk1h4jyzfrxaesjk9838ykv",
  "slug": "rotifer-agent",
  "version": "1.2.1",
  "publishedAt": 1786978439199
}

skill-card.md

## Description:

Build a Rotifer Agent from Genes by decomposing intent into capability units, selecting Genes by Arena fitness, composing a Rotifer Genome, creating the Agent, and testing it.

This skill is ready for commercial/non-commercial use.

## Publisher:

[xiaoba-dev](https://clawhub.ai/user/xiaoba-dev)

### License/Terms of Use:

MIT-0

## Use Case:

Developers and engineers use this skill to design Rotifer-specific agents by decomposing goals into Genes, selecting or creating the required Genes, choosing a Genome composition strategy, and validating the resulting Agent.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: Unpinned npm execution may run a newer @rotifer/playground or @rotifer/mcp-server version than the reviewer expected.

Mitigation: Review or pin the npm package versions before first use.

Risk: Rotifer CLI and MCP commands may read or write project-local Genes and Agent definitions.

Mitigation: Run the skill only in workspaces and with network access appropriate for the project data involved.

## Reference(s):

- [Rotifer Protocol](https://rotifer.dev)
- [Rotifer Documentation](https://rotifer.dev/docs)
- [Rotifer Protocol Specification](https://github.com/rotifer-protocol/rotifer-spec)
- [Rotifer Playground](https://github.com/rotifer-protocol/rotifer-playground)
- [ClawHub Skill Page](https://clawhub.ai/xiaoba-dev/skills/rotifer-agent)
- [Publisher Profile](https://clawhub.ai/user/xiaoba-dev)

## Skill Output:

**Output Type(s):** [Guidance, Markdown, Shell commands, Configuration]

**Output Format:** [Markdown with tables, checklists, JSON snippets, and inline bash commands]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [May propose Rotifer CLI and MCP commands that read and write project-local Rotifer Genes and Agent definitions.]

## Skill Version(s):

1.2.1 (source: server release metadata and clawhub.json)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

clawhub.json

{
  "name": "rotifer-agent",
  "display_name": "Rotifer Agent",
  "description": "Build AI Agents from Genes — decompose intent into capability units, select the fittest Genes from Arena rankings, compose them into a Rotifer Genome with Seq/Par/Cond/Try/TryPool strategies, and validate the pipeline end-to-end.",
  "tagline": "From intent to running Agent in seven steps",
  "version": "1.2.1",
  "author": "rotifer-protocol",
  "license": "Apache-2.0",
  "category": "developer-tools",
  "tags": [
    "rotifer",
    "ai-agent",
    "agent-builder",
    "genome",
    "composition",
    "pipeline",
    "gene",
    "orchestration"
  ],
  "homepage": "https://rotifer.dev",
  "repository": "https://github.com/rotifer-protocol/rotifer-playground",
  "permissions": [
    "process:exec",
    "filesystem:read",
    "filesystem:write",
    "network:outbound"
  ],
  "screenshots": [],
  "demo_video": null
}

Github ReposUpdated 3d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.

MCPOPENCLAW

Github ReposUpdated 7mo agoRank 70

CopilotKit

The Frontend for Agents & Generative UI. React + Angular