Genome Manager

Manage Genome Evolution Protocol (GEP) genomes for AI agent self-evolution. Use when creating, storing, retrieving, mutating, or tracking genomes - the encod...

Security Scan

The skill appears to implement local genome storage and mutation as described, but there are several inconsistencies between the documentation and the code (and missing checks around sensitive data) that warrant caution before installing or sharing genomes.

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.

What to consider before installing

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.

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