← Back to Skills Marketplace
kylechen26

Genome Manager

by Kyle Chen · GitHub ↗ · v1.0.2
cross-platform ⚠ suspicious
739
Downloads
0
Stars
1
Active Installs
3
Versions
Install in OpenClaw
/install genome-manager
Description
Manage Genome Evolution Protocol (GEP) genomes for AI agent self-evolution. Use when creating, storing, retrieving, mutating, or tracking genomes - the encod...
README (SKILL.md)

Genome Manager

Manages the Genome Evolution Protocol (GEP) genomes - structured success patterns that enable AI agents to self-evolve.

What are Genomes?

Genomes are encoded patterns of successful agent behavior:

  • Task Type: Classification (research, debug, security, etc.)
  • Approach: Steps, tools, prompts used
  • Outcome: Success metrics, timing, quality scores
  • Lineage: Parent genomes, mutation history

When to Use This Skill

Use when:

  • Extracting successful patterns from completed tasks
  • Creating reusable genome libraries
  • Mutating genomes for optimization
  • Tracking genome performance over time
  • Preparing genomes for EvoMap sharing

Genome Lifecycle

Experience → Encode → Store → Retrieve → Adopt → Evolve → Share

Quick Start

CLI Usage

This skill provides a command-line tool for genome management:

# Create a new genome
python3 scripts/genome_manager.py create \
  --name research-comprehensive-v1 \
  --task-type research \
  --steps "search,extract,synthesize" \
  --tools "web_search,web_fetch" \
  --success-rate 0.95 \
  --sample-size 50

# List all genomes
python3 scripts/genome_manager.py list

# Get a specific genome
python3 scripts/genome_manager.py get research-comprehensive-v1

# Create a mutated copy
python3 scripts/genome_manager.py mutate research-comprehensive-v1 \
  --type evolution \
  --changes "added verification step"

# Validate genome quality
python3 scripts/genome_manager.py validate research-comprehensive-v1

Programmatic Usage

# Import from skill directory
import sys
sys.path.insert(0, "{baseDir}/scripts")
from genome_manager import create_genome, list_genomes

# Create genome programmatically
genome = create_genome(args)

Genome Schema

{
  "genome_id": "uuid-v4",
  "name": "research-comprehensive-v1",
  "task_type": "research",
  "version": "1.0.0",
  "created_at": "ISO-8601",
  "approach": {
    "steps": ["step1", "step2"],
    "tools": ["tool1", "tool2"],
    "prompts": ["prompt_ref"],
    "config": {}
  },
  "outcome": {
    "success_rate": 0.95,
    "avg_duration_seconds": 180,
    "user_satisfaction": 0.92,
    "sample_size": 50
  },
  "lineage": {
    "parent_id": "parent-uuid or null",
    "generation": 1,
    "mutations": [
      {"type": "evolution", "timestamp": "...", "changes": "..."}
    ]
  },
  "tags": ["research", "comprehensive", "verified"]
}

Storage Locations

Default genome storage:

  • memory/genomes/*.json - Local genome library
  • ~/.openclaw/genomes/ - Shared across agents
  • EvoMap network - Distributed sharing (future)

Mutation Types

Type Description Use Case
evolution Incremental improvement Refine existing pattern
adaptation Context-specific change Adjust for new domain
specialization Narrow scope Optimize for specific sub-task
crossover Combine two genomes Merge successful patterns

Validation Rules

Before saving a genome:

  • Success rate >= 0.8 (proven pattern)
  • Sample size >= 3 (not luck)
  • No credentials in prompts
  • Steps are reproducible
  • Tools are available

Security

  • Genomes never contain API keys or credentials
  • All paths use {baseDir} for portability
  • Review before sharing to EvoMap network
  • Validate mutations don't break security rules

Integration with EvoAgentX

from evoagentx import Workflow
from genome_manager import Genome

# Load genome into EvoAgentX workflow
genome = Genome.load("research-comprehensive-v1")
workflow = Workflow.from_genome(genome)

# Evolve it further
evolution = await workflow.evolve(dataset=test_cases)

Version History

  • 1.0.0: Core genome CRUD operations
  • 1.0.1: Added mutation tracking
Usage Guidance
This tool is essentially a small local JSON CRUD utility for 'genomes' and is not obviously malicious, but there are a few things to check before use: - Expect the script to create and write files to ~/.openclaw/genomes — inspect that directory and the JSON files after any run. - SKILL.md promises some features the code doesn't provide (a Genome class, EvoAgentX integration, 'crossover' mutation). Don't rely on those until they are implemented; the README/examples and code are inconsistent. - The documentation states 'no credentials in prompts' but the validate command does not scan for secrets. Manually review any genome 'prompts' or fields for API keys, tokens, or PII before sharing externally (EvoMap sharing is described as 'future' and not implemented). Consider adding a secrets-scan step before sharing. - Because this skill writes to your home directory, run it as a non-privileged user and inspect the source code locally (you already have it) before invoking from an agent that may run autonomously. - If you plan to integrate with other agent frameworks, verify the programmatic API expectations against the actual code (the code exposes functions, not a Genome class as the docs show). If you want me to, I can: - produce a short patch to implement a basic credentials-in-prompts check in validate_genome, - or run a checklist of test commands to exercise the script safely in a sandboxed environment.
Capability Analysis
Type: OpenClaw Skill Name: genome-manager Version: 1.0.2 The skill bundle is classified as suspicious due to a path traversal vulnerability in `scripts/genome_manager.py`. The `name` argument, used in commands like `create`, `get`, `mutate`, and `validate`, is directly incorporated into file paths (e.g., `GENOMES_DIR / f"{args.name}.json"`) without sanitization. This allows an attacker to use `../` sequences in the genome name to read or write files outside the intended `~/.openclaw/genomes/` directory. While this is a significant vulnerability, it is a flaw that *allows* attacks rather than code *designed* for malicious actions like data exfiltration or remote execution. No prompt injection attempts were found in `SKILL.md`.
Capability Assessment
Purpose & Capability
Overall purpose (manage/create/mutate genomes) matches the shipped script: the Python tool creates, lists, reads, mutates, and validates JSON genomes in ~/.openclaw/genomes. However the SKILL.md and examples claim additional capabilities that the code does not provide (e.g., a Genome class, direct Integration with EvoAgentX/Workflow.from_genome, and the 'crossover' mutation type), and the registry metadata disagrees with SKILL.md's declared required binary (SKILL.md lists python3 in metadata, registry 'Required binaries' is empty). These mismatches are functional inconsistencies (not immediate evidence of malicious intent) but reduce trust.
Instruction Scope
Instructions and CLI usage in SKILL.md largely reflect the script's commands (create, list, get, mutate, validate). But SKILL.md claims validation rules like 'No credentials in prompts' and 'Genomes never contain API keys', while the implemented validate_genome function does not check prompts or scan stored genome contents for credentials—only basic numeric checks. SKILL.md also references future/distributed sharing (EvoMap) and programmatic APIs that are not implemented. The script only reads/writes local JSON files under ~/.openclaw/genomes and does not perform network I/O.
Install Mechanism
This is an instruction-only skill with a small Python script included; there is no install spec, no downloads, and no third-party package install. Nothing will be written to disk by an installer beyond the included files; however the script itself will create and write JSON files into ~/.openclaw/genomes when run.
Credentials
The skill declares no required environment variables or credentials and the code does not read env vars or require API keys. This is proportional to the stated local storage purpose. Note: SKILL.md asserts genomes won't contain credentials, but that is not enforced by code—so stored genomes could accidentally include secrets if the user or an agent writes them.
Persistence & Privilege
The skill is not forced-always; it's user-invocable and can be called by the agent (normal). The only persistence is that the script creates files under the user's home (~/.openclaw/genomes). It does not modify other skills or system-wide configuration.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install genome-manager
  3. After installation, invoke the skill by name or use /genome-manager
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.0.2
Improved description explaining GEP genome lifecycle and collective evolution
v1.0.1
Added real working Python script - genome_manager.py CLI tool
v1.0.0
Initial release - GEP genome management for agent evolution
Metadata
Slug genome-manager
Version 1.0.2
License
All-time Installs 1
Active Installs 1
Total Versions 3
Frequently Asked Questions

What is Genome Manager?

Manage Genome Evolution Protocol (GEP) genomes for AI agent self-evolution. Use when creating, storing, retrieving, mutating, or tracking genomes - the encod... It is an AI Agent Skill for Claude Code / OpenClaw, with 739 downloads so far.

How do I install Genome Manager?

Run "/install genome-manager" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Genome Manager free?

Yes, Genome Manager is completely free (open-source). You can download, install and use it at no cost.

Which platforms does Genome Manager support?

Genome Manager is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Genome Manager?

It is built and maintained by Kyle Chen (@kylechen26); the current version is v1.0.2.

💬 Comments