How MemClaw turns proven fleet behavior into governed, delivered SKILL.md skills — authored by agents or distilled by Forge, gated through a lifecycle, and pushed to the harnesses that run your agents.

The Skills page covers the simplest case: an agent writes a SKILL.md-style document into the skills collection and peers find it via search. Skill Factory is the system around that — it answers three questions the bare collection doesn't:

Where do good skills come from? Agents author them directly, and Forge distills them automatically from what the fleet has repeatedly done well.
How do we trust them? Every skill moves through a governed lifecycle — candidate → staged → active — gated by automated checks, a security scan, and (optionally) human review.
How do they actually reach an agent? Two delivery tiers: agents pull active skills over MCP, or the OpenClaw plugin pushes them onto each node's skill load path.

Skill Factory is opt-in per tenant and off by default. With it disabled, the skills collection behaves exactly as the Skills page describes — no lifecycle, no gating, every stored skill visible. Turning it on activates the three pillars below.

Enable it by setting skills_factory.enabled = true in the tenant's org settings. While it's false, none of the gating, Forge, or Inbox behavior runs — the feature is a true no-op until you opt in.

The three pillars

1. Authoring — agents and Forge

A skill can enter the catalog two ways:

Direct authorship. An agent (or an admin) writes a skill with memclaw_doc op=write collection='skills', exactly as on the Skills page. When Skill Factory is enabled, that write is validated and lands as staged (pending review) rather than instantly visible — see Lifecycle & governance.
Forge. A server-side resident that mines the fleet's memory and outcome signals, clusters repeated successful procedures, and distills them into skill candidates — no agent has to remember to write the skill. Forge runs as a low-trust resident (it can only produce team-scoped skills) on a cadence you control.

2. Governance — the lifecycle

Every skill carries a status. The states form a one-way street toward active, with side exits for anything that fails a check:

                ┌─────────────┐
   Forge ─────▶ │  candidate  │   (internal — never agent-visible)
                └──────┬──────┘
            auto-gates │ pass
                       ▼
 agent write ───▶┌─────────────┐   approve (HITL)   ┌──────────┐
                 │   staged    │ ─────────────────▶ │  active  │ ◀── admin direct-write
                 └─────┬───────┘                    └──────────┘
                       │ reject / scan-flag / hash-drift
                       ▼
        rejected · quarantined · stale · deprecated

Automated auto-gates and a Sentinel security scan decide what may be promoted; a Skills Inbox lets an operator approve, edit, reject, or quarantine staged skills. Only active skills are ever delivered to agents. Full detail in Lifecycle & governance.

3. Delivery — pull and push

Getting a skill to an agent has a hard ceiling depending on the tier:

Tier	Mechanism	Reliability
MCP pull	Agent calls `memclaw_doc op=search` / `op=read` on the `skills` collection and decides to use what it finds.	Probabilistic — the agent has to look, and search has to surface it.
Harness push	The OpenClaw plugin's reconciler pulls every `active` skill from `POST /api/v1/skills/installable` and writes each one to the node's skill directory, then registers that directory on OpenClaw's load path.	Reliable — the skill is on disk and in the agent's skill list, no discovery step.

Both tiers serve only active skills once Skill Factory is enabled — the pull path filters server-side, and the push endpoint returns active-only. A Forge candidate sitting in the Inbox reaches no one until it's approved.

Newly-active skills land on a node's disk and skill registry promptly, but an agent session that is already running keeps its cached skill list until a fresh session starts. Plan rollouts accordingly.

Where to go next

Lifecycle & governance — the statuses, the six auto-gates, the Sentinel scan, and the Skills Inbox review flow.
Skills — authoring and discovering skills directly via memclaw_doc (the foundation Skill Factory builds on).
OpenClaw integration — installing the plugin that performs harness-push delivery.

Where to look in the source

Lifecycle validator + auto-gates: core-api/src/core_api/services/skill_lifecycle.py
Forge resident: core-api/src/core_api/services/forge/
Skills Inbox API: core-api/src/core_api/routes/skills_inbox.py
Harness-push delivery (plugin reconciler): plugin/src/reconcile-skills.ts

Skill Factory