The first reflexive co-evolution engine for multi-agent systems.
Observe structural friction. Attribute root causes. Evolve through evidence.
📖 English Quickstart · 🇨🇳 中文快速入门 · 📐 Design Spec · 💬 Discord
Your multi-agent system has structural problems it can't see. Agents repeat work. Handoffs lose context. Protocols exist but aren't followed. Memory is written but never read. You notice these patterns — weeks later, after the damage compounds. MOLT sees them in real time.
MOLT (蜕界) is a reflexive co-evolution engine for OpenClaw multi-agent systems. It continuously observes your agent team — how they work, how they collaborate, where they fail — and produces structured, evidence-based findings that drive improvement at three levels:
| Level | What MOLT Observes | Example Finding |
|---|---|---|
| Task | Individual agent behavior, memory effectiveness, protocol adherence | "Agent Hulk writes daily summaries to memory but never reads them back — 45 entries written, 0 consumed" |
| Team | Role boundaries, handoff integrity, collaboration patterns | "Jobs and Hulk both independently scan for API key leaks — duplicate effort with no shared state" |
| Host | System capabilities, configuration gaps, environmental friction | "Dreaming is available but not enabled — 3 frictions trace to cross-session memory loss that dreaming would address" |
MOLT doesn't just find problems — it builds evidence chains: observed friction → root cause hypothesis → tracked intervention → measured effect → institutionalized pattern. Every finding is versioned, linked, and auditable.
Most observability tools watch what your system does. MOLT watches how your system is organized — and whether that organization is helping or hurting. The host environment is not sacred. The team structure is not fixed. Everything is an object of evidence-based experimentation.
┌─────────────────────────────────────────┐
│ MOLT Engine │
│ (Prompt-Driven LLM) │
│ │
┌──────────┐ │ observe → attribute → evidence → │ ┌──────────────┐
│ System │─────▶│ propose → settle │─────▶│ Evidence │
│ Model │ │ │ │ Store │
│model.json │◀─────│ ◀── change detection ──▶ │ │ molt.jsonl │
└──────────┘ └─────────────────────────────────────────┘ └──────────────┘
▲ │ │
│ ▼ ▼
┌──────────┐ ┌─────────────────┐ ┌───────────────────┐
│ OpenClaw │ │ CLI (25 cmds) │ │ Weekly Reports │
│ Runtime │ │ molt-cli.sh │ │ Pattern Library │
│ ~/.openclaw│ └─────────────────┘ │ Evolution Advice │
└──────────┘ └───────────────────┘
Four components, one cycle:
-
System Model (
model.json) — MOLT discovers your system at runtime: how many agents, their roles, collaboration mechanisms, host capabilities. No configuration needed — it reads your OpenClaw filesystem directly. -
Engine — A structured LLM prompt (not code) that reasons about your specific system. Same engine + different model = different analysis per user. Single-agent setups get single-agent analysis. 10-agent meshes get team-level friction detection.
-
Evidence Store (
molt.jsonl) — Append-only ledger of all findings. 10 asset types, fully versioned, JSON Schema validated. Every object links to its evidence chain. -
CLI (
molt-cli.sh) — 25 commands for reading, writing, and managing MOLT data.
# 1. Clone & install
git clone https://github.com/OiiOAI/MOLT.git
cd MOLT
bash product/install.sh # Installs all: data + skill + agent + claude-code
# 2. Discover your system
bash ~/.openclaw/molt/molt-cli.sh discoverOutput:
Model created: ~/.openclaw/molt/model.json
Agents: 3 (main, researcher, writer)
Topology: hub_spoke
Multi-agent: True
Dreaming: False
Sessions: 142
Shared artifacts: 5
# 3. Run your first scan (choose one)
/molt scan # Via OpenClaw Skill (in any session)
/molt scan # Via Claude Code Skill
# Or let the Agent do it # Auto-runs daily at 9am via cron
# 4. Review findings
bash ~/.openclaw/molt/molt-cli.sh status
bash ~/.openclaw/molt/molt-cli.sh frictions
bash ~/.openclaw/molt/molt-cli.sh chain FRI-20260410-001That's it. MOLT is now observing your system.
Install → Discover (build model)
↓
┌──── Scan (analyze sessions against model) ←── cron / manual / skill
│ ↓
│ Frictions identified (with source references)
│ Attributions formed (agent / team / environment level)
│ Evidence tracked (is the problem being addressed?)
│ Evolution proposals generated (what to change)
│ ↓
│ Review (approve / reject / discuss)
│ ↓
│ User executes improvements
│ (modify config / adjust AGENTS.md / add agent / enable feature)
│ ↓
│ Next scan detects model changes + evaluates improvement effects
└───────┘
↓
Weekly Report (digest of friction trends, evidence status, proposals)
Key difference from traditional monitoring: MOLT doesn't just detect problems — it tracks whether your fixes actually worked, and promotes recurring patterns into institutional knowledge.
MOLT doesn't assume what your system looks like. It discovers it.
Adaptive analysis paths:
- Single agent → memory effectiveness, protocol adherence, capability gaps
- Multi-agent hub-spoke → role boundaries, handoff integrity, coordinator bottleneck
- Multi-agent mesh → shared state conflicts, duplicate effort, collaboration artifact effectiveness
- Any configuration → the engine reasons from the model, not from hardcoded checks
Every MOLT finding is a structured, versioned JSON object appended to molt.jsonl:
| Asset | ID Format | Purpose |
|---|---|---|
| Batch | BAT-YYYYMMDD-NNN |
Groups findings from a single scan |
| Friction | FRI-YYYYMMDD-NNN |
Observed structural problem with source references |
| Attribution | ATT-YYYYMMDD-NNN |
Root cause hypothesis (agent / team / environment level) |
| Evidence | EVO-YYYYMMDD-NNN |
Intervention record and measured effect |
| Candidate | CAN-YYYYMMDD-NNN |
Emerging pattern not yet confirmed |
| Pattern | PAT-YYYYMMDD-NNN |
Confirmed recurring pattern (promoted from candidate) |
| Settlement | SET-YYYYMMDD-NNN |
Scan summary packet |
| Evolution Proposal | EVO-PROP-YYYYMMDD-NNN |
Proposed improvement with risk assessment |
| Model Snapshot | SNAP-YYYYMMDD-NNN |
Records system structural changes |
All assets follow JSON Schema definitions in product/schema/. Every object is versioned (immutable history), linked (evidence chains), and append-only (no data loss).
Example: A friction with its evidence chain
// Friction: observed problem
{
"id": "FRI-20260401-002",
"type": "friction",
"title": "Hulk skips exhaustive scan, reports no API key leaks despite real keys present",
"severity": "high",
"source_refs": ["session:hulk:2026-04-01-security-audit.jsonl:L42-L67"],
"status": "active"
}
// Attribution: root cause hypothesis
{
"id": "ATT-20260401-002",
"type": "attribution",
"target_friction_id": "FRI-20260401-002",
"attribution_level": "agent_level",
"hypothesis": "AGENTS.md security protocol lacks explicit 'scan all files' directive",
"confidence": "high"
}
// Evidence: tracking the fix
{
"id": "EVO-20260401-002",
"type": "evidence",
"linked_friction_id": "FRI-20260401-002",
"primary_intervention_type": "protocol_update",
"effect_status": "improved",
"after_state_summary": "Added explicit scan directive; subsequent audit found all keys"
}One engine core prompt, three ways to use it:
| Form | Install | Trigger | Best For |
|---|---|---|---|
| OpenClaw Agent | install.sh agent |
Cron (daily 9am + weekly Monday 10am) | Hands-off continuous observation |
| OpenClaw Skill | install.sh skill |
/molt scan in any session |
On-demand analysis during work |
| Claude Code Skill | install.sh claude-code |
/molt scan in Claude Code |
Developers managing OpenClaw via CLI |
# Install specific form
bash product/install.sh agent # Agent only
bash product/install.sh skill # Skill only
bash product/install.sh claude-code # Claude Code only
bash product/install.sh all # Everything (default)All three forms share molt-engine-core.md as the single source of truth. The installer embeds the engine core into each form's prompt file at install time.
25 commands organized by function (click to expand)
molt-cli.sh discover # Build/update System Model from OpenClaw runtime
molt-cli.sh model # Display model summary
molt-cli.sh model-diff # Check for system changes since last scan
molt-cli.sh scan # Scan instructions (requires LLM)
molt-cli.sh report # Generate weekly markdown reportmolt-cli.sh status # Evidence store summary (counts by type/status)
molt-cli.sh frictions # List active frictions by severity
molt-cli.sh candidates # List pattern candidates
molt-cli.sh attributions # List active attributions
molt-cli.sh evidence # List evidence records
molt-cli.sh settlements # List settlements
molt-cli.sh recurring # Show recurring patterns
molt-cli.sh chain <ID> # Trace full evidence chain for any object
molt-cli.sh history <ID> # Show version history for any objectmolt-cli.sh approve <FRI-ID> # Mark friction as reviewed
molt-cli.sh reject <FRI-ID> <reason> # Reject a friction with reason
molt-cli.sh close <ID> <note> # Close any object with note
molt-cli.sh promote <CAN-ID> # Promote candidate → pattern
molt-cli.sh propose <level> <title> # Create evolution proposal
molt-cli.sh update-evidence <EVO-ID> # Update evidence effect status
molt-cli.sh approve-evo <EVO-PROP-ID> # Approve evolution proposal
molt-cli.sh reject-evo <EVO-PROP-ID> <reason> # Reject evolution proposalmolt-cli.sh backup # Backup evidence store
molt-cli.sh recommend <FRI-ID> # Get action recommendation for a friction| Traditional Monitoring | MOLT | |
|---|---|---|
| Watches | What the system does (errors, latency, throughput) | How the system is organized (team structure, collaboration patterns, capability gaps) |
| Finds | Symptoms | Structural root causes with three-layer attribution |
| Tracks | Incidents | Evidence chains (friction → hypothesis → intervention → effect → pattern) |
| Adapts to | Predefined metrics and thresholds | Whatever system the user actually built — discovered at runtime |
| Proposes | Alerts | Tiered evolution proposals (task / team / host) with risk assessment |
| Learns | Resets each incident | Accumulates institutional knowledge — candidates mature into patterns |
- The host environment is questionable — it's an object of experimentation, not a sacred given
- Friction must be trackable — every observation becomes a structured, versioned object
- Improvement requires evidence — no changes without a chain from observation to measured effect
- Learning targets are dual-layer — both agent team AND host environment evolve
- Changes must be tiered — task/team/host changes have different thresholds and review gates
MOLT never hardcodes OpenClaw features. It discovers capabilities at runtime:
OpenClaw ships new feature (e.g., Dreaming)
→ User updates but doesn't enable it
→ molt discover detects: dreaming available but not enabled
→ Engine finds memory-loss friction
→ Produces evolution_proposal: "Enable Dreaming to address cross-session memory loss"
→ User enables Dreaming
→ Next scan: model change detected → new observation dimension activated
→ Evaluates whether Dreaming actually fixed the prior frictions
No feature-specific code written. The engine's generic observation framework ("host provides capability X but user hasn't enabled it") handles any new OpenClaw feature automatically.
MOLT Phase 1 was piloted on a 7-agent OpenClaw instance over 2 weeks:
| Metric | Result |
|---|---|
| Evidence objects produced | 76 |
| Structural frictions identified | 13 |
| Root cause attributions | 13 |
| Evidence records tracked | 13 |
| Pattern candidates emerged | 1 (with 10 linked frictions) |
| Weekly reports generated | 2 |
| Three-layer attribution accuracy | Validated by human review |
Frictions discovered included: protocol non-compliance, duplicate cross-agent work, tool chain failures propagating silently, shared state written but never consumed, and security findings repeatedly surfaced but not acted upon.
MOLT is a native OpenClaw product. It reads the OpenClaw filesystem directly — no API keys, no configuration, no external services.
Works with any OpenClaw setup:
- Default single-agent installation
- Custom multi-agent teams (2–50+ agents)
- Any combination of channels (Discord, Telegram, Lark, WeChat)
- Any collaboration structure the user has built
Relationship with other agents:
- MOLT does NOT communicate with other agents via messaging
- MOLT reads the filesystem to observe other agents' sessions, memory, and workspace
- MOLT's only write target is its own data directory
- MOLT never modifies another agent's files
Full directory structure (click to expand)
~/.openclaw/molt/ # MOLT data directory
├── model.json # System Model (your system's structure)
├── molt.jsonl # Evidence Store (append-only)
├── molt-cli.sh # CLI tool
├── schema/ # JSON Schema definitions (10 asset types)
│ ├── model.schema.json
│ ├── batch.schema.json
│ ├── friction.schema.json
│ ├── attribution.schema.json
│ ├── evidence.schema.json
│ ├── candidate.schema.json
│ ├── pattern.schema.json
│ ├── settlement.schema.json
│ ├── evolution_proposal.schema.json
│ └── model_snapshot.schema.json
├── reviews/ # Weekly reports (week-YYYY-WNN.md)
└── backups/ # Automatic backups
~/.openclaw/skills/molt/ # OpenClaw Skill form
└── SKILL.md # Engine prompt (core embedded)
~/.openclaw/workspace-molt/ # OpenClaw Agent form
├── SOUL.md # MOLT identity
├── AGENTS.md # Engine prompt (core embedded)
└── molt/ → ~/.openclaw/molt/ # Symlink to shared data
| Phase | Status | Description |
|---|---|---|
| Phase 1 | Shipped | Observation → Attribution → Evidence pipeline. Read-only system analysis. |
| Phase 2 | Defined | Controlled write-back. Proposal → Experiment → Adoption objects. MOLT proposes config changes for user approval. |
| Phase 3 | Planned | Cross-host learning. Multiple OpenClaw instances share anonymized patterns. |
| Phase 4+ | Vision | Autonomous evolution within constitutional constraints. Self-modifying team structures with evidence gates. |
| Document | Language | Description |
|---|---|---|
| English Quickstart | EN | 5-minute setup guide |
| 中文快速入门 | CN | 5 分钟入门指南 |
| Design Spec | EN | Full architecture and design decisions |
| Strategic Roadmap | CN | 7-phase evolution roadmap |
| Phase 1 Pilot | CN | Pilot scope and success criteria |
| Phase 2 Definition | CN | Controlled write-back system |
| Comprehensive Handbook | CN | Complete reference (all phases) |
MOLT/
├── product/ # Distributable product
│ ├── engine/molt-engine-core.md # Shared engine prompt (source of truth)
│ ├── cli/molt-cli.sh # CLI (25 commands, ~1400 lines)
│ ├── schema/ # JSON Schemas (10 asset types)
│ ├── agent/ # OpenClaw Agent (SOUL.md, AGENTS.md, cron.json)
│ ├── skill/ # OpenClaw Skill (SKILL.md + references)
│ ├── claude-code-skill/ # Claude Code Skill (SKILL.md)
│ └── install.sh # Installer (data/skill/agent/claude-code/all)
├── quickstart/ # Bilingual quickstart guides
├── docs/ # Design specs and implementation plans
└── *.md # Strategic documentation (Chinese)
- OpenClaw installed at
~/.openclaw/ - Python 3.6+
- An LLM provider (Claude, GPT, etc.) for scan execution
MOLT is in early release. We welcome:
- Bug reports and friction reports (yes, we eat our own dogfood)
- Analysis dimension suggestions (what should MOLT observe that it doesn't?)
- Engine prompt improvements (better reasoning, fewer false positives)
- New asset type proposals
- Translations
Please open an issue or join the Discord.
MIT — see LICENSE for details.
If you use MOLT in your research or product, please cite:
@misc{molt2026,
author = {V and OiiOAI},
title = {MOLT: Reflexive Co-evolution Engine for Multi-Agent Systems},
year = {2026},
publisher = {GitHub},
url = {https://github.com/OiiOAI/MOLT}
}蜕界 — The world molts. So should your system.
{ // Layer 1: What can OpenClaw provide? "host": { "capabilities": { "multi_agent": true, "dreaming": false, // Available but not enabled "memory_search": "hybrid", "cron": true, "channels": ["discord", "telegram"] } }, // Layer 2: What agent team did the user build? "team": { "agents": [/* discovered from filesystem */], "topology": { "type": "hub_spoke" } }, // Layer 3: How does the team coordinate? "collaboration": { "shared_artifacts": ["KANBAN.md", "BULLETIN.md"], "handoff_mechanism": "session_send", "coordination_protocols": ["HANDOFF.md", "CONTINUE.md"] }, // Layer 4: How is the system actually used? "runtime_profile": { "session_stats": { "total_sessions": 881 }, "observation_period": "2026-03-01/2026-04-10" } }