Skill Evolution
Agents autonomously learn, test, and deploy new skills through a 42-module native evolution system — no external dependencies, no CLI wrappers, no AGPL risks.How It Works
The evolution engine follows a Retrieve-Before-Generate strategy: before creating new solutions, it searches existing high-confidence fixes. This alone eliminates redundant LLM calls.- Discovery — Agent identifies a recurring task pattern or detects a failure signal
- Evidence Aggregation — Collects success and failure cases across multiple executions
- Variant Generation — Creates 3 candidate variants in parallel (cost-efficient vs competitors’ 50-500 LLM calls)
- Scoring — LLM-as-Judge evaluation with four dimensions (Function / Quality / Safety / Compatibility)
- Improvement Gate — The original skill competes as a baseline candidate; only variants that genuinely outperform it survive
- Approval — GUI-based human approval workflow with diff preview
- Deployment — A/B tested with automatic rollback on regression
Directed Skill Learning: /learn
In addition to automatic skill extraction, you can teach the agent new skills on demand using the /learn command in any chat:
The
/learn command works across all channels — WebUI, Telegram, and any connected IM platform. The generated skill follows strict authoring standards (frontmatter, 8-section structure, quality bar) and is saved through the same security pipeline as auto-captured skills.
vs competitors: Hermes /learn requires arguments (errors on empty input) and only works in CLI. Myrm’s /learn handles empty arguments gracefully, works across all channels, and feeds into the full quality pipeline (10-dim scoring, dedup, lifecycle management).
Learning by Demonstration
Show the agent a “before → after” example and it automatically infers the transformation rule:- Upload your original file and the expected result (Excel, CSV, text, code — any format)
- Agent analyzes the differences, infers the transformation logic, and writes a script
- Validates by executing the script and comparing output against your expected result
- Captures the validated pattern as a reusable skill via
StructuredExtractor
StructuredExtractor automatically classifies whether the pattern deserves to be a skill, cron_job, or is too trivial to capture (skip), with built-in safety_analysis to detect destructive commands or credential exposure.
vs competitors: All competitors require manual template authoring or macro recording. Myrm’s approach is fully conversational and leverages LLM understanding — it generalizes from examples rather than replaying exact steps.
Learning from Human Takeover
When the Agent gets stuck during a browser task, it can ask you to take over. Your actions then become learning material — automatically and transparently:- Agent requests takeover — You see a prompt asking for control
- You operate the browser — Navigate, click, fill forms as needed
- System captures the change — Pre/post page snapshots are recorded (semantic accessibility tree, not pixels)
- Toast confirmation — You see “Behavior recorded — Agent will learn from your demonstration”
- Evolution consumes the evidence — Next time the FIX or DERIVED pipeline triggers, your demonstration appears alongside execution traces
Automatic Multi-Step Workflow Learning
Every time you complete a task, the agent automatically analyzes the full conversation — including all tool calls, their parameters, ordering, and context — to identify reusable multi-step patterns. If a workflow is generalizable, it’s captured as a new skill on the first occurrence.
Why this matters: You don’t have to repeat yourself three times before the agent “notices” a pattern. One well-executed workflow is enough — the agent learns immediately and adapts the knowledge to future variations.
Four Evolution Types
5-Layer Safety
Every evolved skill passes through five independent safety gates before reaching production:Frustration Detection
The system detects user dissatisfaction through 5 categories and 38 bilingual patterns (Chinese + English), triggering DERIVED evolution without explicit user feedback:- Verbosity — “just give me the answer”
- Style — “be more concise”
- Format — “use a table instead”
- Workflow — “stop doing X first”
- General — frustration expressions
Evidence-Driven Evolution
Unlike competitors that evolve from single failure signals, Myrm aggregates evidence across multiple executions:- Success cases — preserved to prevent regressions
- Failure cases — analyzed for root cause patterns
- Minimum evidence threshold — requires at least 3 executions and 1 failure before triggering evolution
Smallest Appropriate Form
When the agent captures a behavior pattern, it doesn’t blindly create a skill. Instead, it classifies the smallest appropriate execution form in the same LLM call — zero extra cost:
This means fewer noisy proposals in your inbox, and clear guidance when something is better suited as a scheduled task rather than an on-demand skill.
vs competitors: No competitor (Hermes, OpenClaw, Codex) offers automatic form classification. All produce only skills, leaving users to manually create cron jobs.
Proactive Skill Recommendation
When the agent encounters a request it cannot fulfill with current tools, it automatically searches the Skill Hub before declining. This “search before saying no” behavior is enforced at two levels:- System Rules — A global behavior rule instructs all models to check for discovery tools before declining
- Tool Description — The discovery tool itself uses MUST-level instructions
tool_search (735 lines) is Progressive Tool Disclosure for already-registered tools, not capability discovery.
Quality Monitoring
3-dimensional degradation detection with sliding window statistics:- Success rate monitoring with configurable threshold (default: 70%)
- P95 latency tracking with automatic alerting
- Server error rate (5xx) monitoring
Stop-Loss: Versions, Shadow A/B, and Batch Snapshots
Plain language: If an evolved skill makes your agent worse, you can roll back in Settings — no CLI. You can also approve changes in Shadow mode first (production behavior stays on the old version while we compare in the background), then promote when metrics look good. Batch-optimizing many skills saves a snapshot before it starts; you can cancel and roll back mid-run if results go sideways. Verified (2026-06-06): 34 automated tests cover batch cancel/rollback (including multi-skill, partial-failure HTTP disk restore, and await-timeout skip-rollback), schedulercancel_batch_optimization + await_batch_optimization wiring, and real disk restore for restore_skill_snapshot (both DB branches). Cancel stops in-flight batch optimization via harness cancellation tokens before rollback restores snapshots; if await times out, rollback is skipped and the user is directed to the detail page. Cancel-with-rollback returns the same rolled_back/failed/total_skills/error_message stats as the batch rollback endpoint; the Web UI shows success, partial (cancelRollbackPartial / rollbackPartial), or failure toasts. Full GUI click-through E2E requires a running backend.
vs competitors: Hermes/OpenClaw offer CLI or file-based rollback; none ship a full GUI loop for shadow validation plus batch mid-flight rollback.
Known Pitfalls: Auto-Learning from Failures
Myrm automatically extracts structured “pitfalls” from skill execution failures and feeds them back into future prompts — your agent avoids the same mistake twice.
Plain language: When a skill fails due to a known issue (e.g., npm timeout), Myrm remembers it and explicitly warns the AI on the next evolution attempt. Over time, your skills become more robust automatically — no manual documentation needed.
vs competitors: Hermes includes a plain-text “Pitfalls” paragraph in skills. Myrm provides structured storage with severity levels, automatic extraction from runtime errors, deduplication with occurrence counting, and prompt engineering injection — a complete closed-loop learning system.
Decision History: Dual-Loop Learning
Every evolution outcome — success or failure — is permanently recorded and automatically fed into future evolution attempts. The agent accumulates institutional knowledge over time, remembering both what worked and what didn’t.
How it works: The 5 most recent constraints are automatically injected into the LLM prompt as “Historical Constraints (MUST obey or rejection is guaranteed)” — so the next evolution attempt builds on accumulated wisdom instead of starting from scratch.
Plain language: Your agent gets smarter with each evolution cycle. If a fix worked well, it remembers why. If a proposal was rejected, it won’t try the same approach again. Over months of use, your skills accumulate a rich history of lessons learned — all automatic, zero maintenance.
vs competitors: SkillHone (Tencent) uses a Git server (Forgejo) with Issues/PRs/Wiki to record decision history — requiring docker compose setup and manual browsing. Myrm stores everything in SQLite with zero external dependencies and automatically injects lessons into future prompts. No other competitor offers dual-loop (success + failure) persistent learning.
Curator: Lifecycle Governance
Automated skill lifecycle management through the Curator system:- Real usage-driven decisions — Skill select /
[use skill]writes.stats.json; Curator sweeps use actual call data, not empty sidecars - Zero background token cost — Stale/archive/LRU are deterministic; consolidation (umbrella merge) is off by default until you opt in
- Prebuilt immunity — 45+ built-in skills under
/prebuilt/are never auto-archived - Dual one-click sweep — Settings “Run now” + Agent config Radar “Smart Prune” with toast feedback
- Never-used protection — Grace period + stale threshold; newly installed skills are not instantly marked idle
- Cluster detection — Prefix + embedding finds semantically similar skills
- Umbrella merge — GUI preview + confirm; no accidental consolidation
- Auto recovery — Stale skills return to active on next use
- Hermes migration usage preserved — Imported call counts and last-used timestamps survive; Curator does not false-stale active skills
- History visualization — GUI timeline; every sweep is traceable
- Single hygiene SSOT — Stale/archive cleanup runs only via Settings Curator and Agent Smart Prune; chat discover does not mount a read-only analyze tool (7/7 peer repos have no equivalent Agent tool)
Conversational Skill Management
Install, search, and manage skills directly from the chat — no settings page needed.Chat Commands
Simply tell the agent what you need in natural language:7-Source Skill Marketplace
Skills are discoverable from multiple ecosystem sources — not locked to a single repository:- GitHub — public skill repositories
- ClawHub — community skill hub
- LobeHub — LobeChat ecosystem skills
- skills.sh — curated skill registry
- ModelScope — 80K+ Chinese AI ecosystem
- Aliyun — AgentExplorer marketplace
- Prebuilt — 45+ bundled skills
Security-First Installation
Every skill passes through a security pipeline before activation:- Quarantine isolation — installed in a sandboxed directory
- AST analysis — static code analysis for dangerous patterns (113 rules)
- LLM semantic audit — AI reviews the skill’s intent and behavior
- Pattern scanning — regex-based detection of known malicious patterns
- Trust scoring — initial trust level with time-based attenuation
GUI Management (33 Components)
Beyond chat commands, a full visual management system is available in Settings:- Discover & search — filterable skill marketplace with categories
- Import — URL import, batch import, file upload
- Export & share — ZIP packaging with SHA-256 integrity and PII auto-redaction
- Permissions — granular permission approval and usage monitoring
- Versions — full version history with one-click rollback
- Evolution tracking — pending proposals, rejection audit, quality monitoring
- Sync — cross-device synchronization via iCloud/Dropbox/NAS
git clone and YAML configuration. No competitor offers in-chat skill search, security-scanned installation, or a 33-component visual management system.
Skill Library
45+ prebuilt skills available out of the box, with multi-source marketplace integration (GitHub, ClawHub, LobeHub, skills.sh, ModelScope). Includes specialized skills for Obsidian Canvas, Obsidian Bases, data analysis, deep research, Unreal Engine MCP (scene building, Blueprint authoring, lighting), Blender MCP (mesh creation, materials, animation), and more — each with structured contracts (steps, traps, verification).Toolset-Aware Skills
Skills automatically adapt to your deployment environment. Each skill can declare which tools or tool groups it requires:- requires_tools / requires_tool_groups — skill only appears when specific tools are available
- fallback_for_tools / fallback_for_tool_groups — skill auto-activates as a tutorial/workaround when a native tool is missing
Zero-Roundtrip Skill Injection
When you explicitly invoke a skill (e.g., “use code-review”), Myrm injects the full SOP directly into context — no extra LLM tool call needed. This saves 2-5 seconds and 500-2000 tokens per invocation compared to the traditional “request → LLM calls select tool → load SOP” flow. The injected payload includes:- Full SOP content with
${SKILL_DIR}template variables resolved [Skill directory: /path/to/skill]for file access- Auxiliary file listing (scripts, references, templates)
[IMPORTANT: The user has invoked...]strong-signal header for model compliance
Three-Way Hash Protection
When Myrm upgrades bundled prebuilt skills, user customizations are never silently overwritten:
Under the hood,
origin_hash (SHA-256 of the bundled source at last sync) is compared against the current stored content hash. If they differ, the user has customized the skill and the upgrade is deferred — not forced.
This solves a common problem with prebuilt/template systems: users who tweak defaults lose their changes on every update.
Skill Config Hot Reload
When you edit skills, agent bindings, or related settings in the WebUI, changes take effect on the next chat message — no server restart and no manual reload command. What happens under the hood:- The settings API bumps a config version stored as a small file under your data directory (
MYRM_DATA_DIR/.skill_config_version). - Before handling your next message, the agent compares its cached version against that file.
- If stale, it clears the skill loader cache and re-initializes only what changed.
/reload-skills CLI step.
Prompt cache: Re-init happens only when skills actually change, so unrelated conversations keep their cache benefits.
6 Concurrent Self-Evolution Mechanisms
Myrm doesn’t wait for you to notice problems — six independent background mechanisms keep your agent learning 24/7:
All proposals flow through the approval pipeline before taking effect — your agent learns constantly but never changes without your consent.
Growth Dashboard
Track your agent’s learning progress with a comprehensive 5-tab visualization system: Overview — Full-picture at a glance- 4 KPI cards — total memories (with weekly delta), skills learned (with evolution count), active days (with streak), memory health score
- Cost savings card — cache savings + routing savings + total cost
- 84-day activity heatmap — GitHub-style visualization of usage patterns
- Multi-dimensional health radar — instant view of memory system health
- Weekly summary — conversations, messages, cron executions, tool calls with week-over-week delta arrows
- Skill evolution timeline — recent proposals with 7 statuses (pending review/auto-applied/failed scan/blocked/approved/rejected/apply failed)
Daily Work Journal
The Daily Journal tab provides a consolidated view of everything your agent did on any given day:- Overview metrics — sessions, tokens, cost, tool calls, approvals, cron runs, kanban events
- Source breakdown — sessions grouped by origin channel (Web UI, Telegram, API, etc.)
- Unified timeline — all events (sessions, approvals, cron runs, kanban events) sorted chronologically
- Date navigation — browse any past day with a date picker
- Agent filtering — filter by specific agent when running multiple agents
Multi-Agent Skill Scoping & Sharing
In a multi-agent sandbox, skills are perfectly isolated yet securely shareable.- Scope Isolation: Skills natively belong to the agent that learned them. They don’t pollute a global pool like in OpenClaw or Hermes.
- Cross-Agent Mounting: Users can mount a skill from Agent A to Agent B with a single click in the GUI, complete with a visual origin badge.
- Copy-on-Write (CoW) Forking: If Agent B evolves a skill mounted from Agent A, Myrm automatically forks a localized variant for Agent B. Agent A’s original skill remains untouched and pristine.
- 1-Click Rollback: Undo an evolution on a CoW fork, and the system intelligently restores the cross-agent mount mapping, retaining complete semantic history.
- Robust Garbage Collection: Deleting an agent cascade-deletes its exclusive skills (both database records and physical
rmtreewipe with path boundary protection), leaving zero orphan data or “ghost” skills.
Zero-Overhead Global Registry
Unlike competitors that require dedicated database tables (shared_capability + shared_capability_version + agent_capability_binding) and a materialization layer to achieve “maintain shared capabilities once,” Myrm’s architecture makes this free:
Competitors solve “shared capability deduplication” with 3 extra database tables and a runtime materialization query. Myrm’s GUI-centric architecture eliminates the problem entirely — skills are naturally singletons referenced by ID.
Per-Session Skill Scope
Beyond agent-level scoping, Myrm supports per-session skill selection — choose exactly which skills are active for each conversation:- Visual Toggle: A sparkle icon (✦) in the message input opens a popover listing all enabled skills. Toggle off anything irrelevant to the current task.
- Token Savings: Disabling unused skills removes their prompt fragments, saving ~1800 tokens per turn in typical 9-skill setups.
- Sharper AI Focus: Fewer candidate skills means less LLM decision noise — the agent picks the right skill faster.
- Persistent Override: Your selection is stored server-side (in
session_loaded_skill_names), surviving page reloads, context compaction, and conversation forks. - Auto-Clear on Agent Switch: Changing the bound Agent automatically resets the skill scope to the new Agent’s defaults.
active_skill_ids with a similar UI. OpenClaw has config-level skillFilter (no GUI). CoPaw supports runtime filtering (no GUI). Hermes, DeerFlow, and jiuwenclaw have no session-level skill scoping at all.
Cross-Device Skill Sync & Privacy
Myrm is the only AI agent platform offering bidirectional skill synchronization with export-time PII redaction — no competitor implements either capability. Sync architecture (Protocol-driven, backend-agnostic):- Pull-first strategy: Remote changes apply before local pushes, preventing accidental overwrites
- SHA-256 incremental tracking: Only changed skills transfer — no full-scan overhead
- Quality gate: Skills must meet minimum thresholds (e.g., ≥3 executions, ≥70% success rate) before being shared
- Background auto-sync: Runs during idle time via the IdleTask system — zero disruption to active work
- Plug-and-play backends: Use iCloud Drive, Dropbox, or any NAS as the sync medium
- API keys (GitHub, Stripe, AWS, SendGrid, HuggingFace, Slack, Replicate, and more)
- Environment variables, JSON secret fields, database connection strings
- CLI flags, URL parameters, Telegram bot tokens, HTTP Authorization headers
- PEM private keys, absolute file paths (with smart system-path exclusion)
- Structured diff preview lets users review and selectively override each redaction
SandboxValidator before activation — malicious code never reaches your workspace.
Compared to Alternatives
vs Hermes Ecosystem Plugins
Hermes requires 5 separate third-party plugins to approximate what Myrm provides natively:
Key advantages of Myrm’s native approach:
- No dependency fragmentation — a single product vs 5 separate repos with different maintainers, licenses, and update cycles
- Deeper integration — evolution system talks directly to security, context management, and GUI layers
- GUI-first experience — every feature has visual management vs CLI-only tooling
- Production-grade safety — 5-layer evolution safety + 6-layer platform security vs ad-hoc checks
Dual-View Review Experience
Myrm’s Skill Growth dashboard supports two view modes, switchable with a single click:
In Simple mode, each card includes a “View changes” link that expands the diff on demand — no performance penalty until you actually need it. Your preference is persisted in localStorage across sessions.
Growth Center data plane (2026-07)
Settings → Skills → Pending Evolutions uses a three-layer read path so large diffs never slow the list:
Verified by 10+ pytest + Chrome MCP E2E on real
:3000 UI: seed → API asserts → stat cards → filter → refresh → lazy diff.
No competitor offers a GUI-based skill review dashboard. OpenClaw uses CLI commands (openclaw skills workshop apply <id>). Other competitors either have no skill evolution system or rely entirely on CLI/text-based approval.
Data Flywheel Dashboard
Myrm provides a 6-panel data flywheel visualization system — the most comprehensive skill analytics in the industry:
The complete flywheel loop runs automatically: Capture traces → Extract skills → Quality gate → Reject bad proposals → Feedback to improve. No manual configuration required.