Mentor

Self-improving orchestration and evaluation engine for long-running multi-skill workflows. Analyzes journals, evaluates variants, and proposes skill improvem...

Mentor is the system's control plane — in runtime mode it decomposes goals into task graphs, supervises execution across skills, and dynamically repairs failures through a layered escalation policy from local retry up to full strategy replan. In heartbeat mode it reads journals from every skill, scores OKR performance against baselines, and generates improvement proposals that flow to Forge and Fellow for empirical evaluation and promotion.

Mentor and Elephas are parallel journal consumers: Mentor reads journals to evaluate skill performance, Elephas reads them to extract entity knowledge into Chronicle, and neither blocks the other.

When to use

• Manage a long-running multi-step project
• Coordinate work across multiple skills
• Evaluate skill performance from journal data
• Compare champion vs challenger variant runs
• Generate improvement proposals for Forge

When not to use

• Web research — use Sift
• Building new skills — use Forge
• User communication — use Dispatch
• Behavioral pattern analysis — use Corvus

Responsibility boundary

Mentor owns orchestration, evaluation, and the improvement loop.

Mentor does not own: skill building (Forge), behavioral pattern detection (Corvus), behavioral refinement (Praxis), knowledge graph (Elephas), web research (Sift), communications (Dispatch), experimentation execution (Fellow).

Mentor proposes improvements; Forge builds them. Mentor detects regressions; Praxis extracts behavioral lessons from Corvus signals.

Commands

• mentor.project.create — create a project with goal, constraints, and requested output
• mentor.project.status — current project state, task graph, execution progress
• mentor.project.replan — trigger strategy-level replan
• mentor.task.list — tasks with statuses, dependencies, blocking reasons
• mentor.heartbeat.light — lightweight pass: ingest journals, update aggregates, queue work
• mentor.heartbeat.deep — deep pass: full scoring, trend analysis, proposals
• mentor.variants.list — active champion/challenger pairs with evaluation status
• mentor.variants.decide — emit promotion decision for a variant (writes VariantDecision to Forge intake)
• mentor.proposals.list — pending skill improvement proposals
• mentor.proposals.create — generate a VariantProposal for a target skill (writes to Forge intake)
• mentor.status — active projects, pending evaluations, self-improvement metrics
• mentor.journal — write journal for the current run; called at end of every run
• mentor.update — pull latest from GitHub source; preserves journals and data
• mentor.plan.list — list available plans with plan_id, version, and description
• mentor.plan.run {plan_id} [--arg name=value ...] — execute a named workflow plan
• mentor.plan.status {plan_run_id} — current state of a running or recent plan run
• mentor.plan.resume {plan_run_id} — continue a paused or failed plan run from the first incomplete step
• mentor.plan.history [--plan plan_id] [--limit N] — recent plan run summaries

Mode A — Runtime orchestration

Triggered by explicit invocation. Creates a project record, builds a task graph, executes and supervises tasks, dynamically replans when blocked.

Task states: pending, ready, running, blocked, failed, complete, archived.

Scheduling: execute only tasks with complete dependencies. Prioritize critical path. Bounded parallelism. Bounded retries.

Mode B — Heartbeat evolution

Triggered periodically. Pipeline: ingest journals → validate schema → aggregate metrics → pair champion/challenger → score OKRs → detect anomalies → evaluate variants → generate proposals → emit decisions → write journal.

Mentor reads journals from all skills at: ~/openclaw/journals/ (recursive scan). It tracks which run_ids have been ingested via ~/openclaw/data/ocas-mentor/ingestion_log.jsonl.

Run completion

After every Mentor command (orchestration or heartbeat):

1. Check ~/openclaw/data/ocas-mentor/intake/ for CycleResult files from Fellow; process and move to intake/processed/
2. Persist project state, evaluation results, or proposals to local files
3. For experiment requests: write ExperimentRequest file to ~/openclaw/data/ocas-fellow/intake/{experiment_id}.json, then invoke fellow.experiment.run
4. For variant proposals: write VariantProposal file to ~/openclaw/data/ocas-forge/intake/{proposal_id}.json
5. For variant decisions: write VariantDecision file to ~/openclaw/data/ocas-forge/intake/{decision_id}.json
6. Log material decisions to decisions.jsonl
7. Write journal via mentor.journal

Layered evaluation loops

• Layer 1 — Micro Action (ms-sec): validate single outputs. Retry, local repair, fallback.
• Layer 2 — Task Execution (sec-min): ensure task completion. Retry, switch skill, split task.
• Layer 3 — Strategy (min-hr): improve active project plan. Reorder, insert, merge, parallelize.
• Layer 4 — Evolution (hr-wk): improve skills and policies. Propose variants, promote/archive.

Failure repair policy

Order: retry with refined framing → alternate skill → split task → revise ordering → escalate to strategy loop. Never retry indefinitely. Every repair action journaled.

Safety invariants

• Challenger variants never execute side effects
• Comparisons only on identical normalized inputs
• Malformed journals quarantined, not trusted
• Promotion requires sufficient evidence over multiple runs
• Mentor journals its own orchestration decisions

Inter-skill interfaces

Mentor writes ExperimentRequest files to: ~/openclaw/data/ocas-fellow/intake/{experiment_id}.json Written when empirical evaluation is needed. Mentor then invokes fellow.experiment.run. Fellow writes the result back.

Mentor receives CycleResult files from Fellow at: ~/openclaw/data/ocas-mentor/intake/{cycle_id}.json Read during mentor.heartbeat.light and mentor.heartbeat.deep. On decision: promote, Mentor emits a VariantDecision to Forge.

Mentor writes VariantProposal files to: ~/openclaw/data/ocas-forge/intake/{proposal_id}.json Mentor writes VariantDecision files to: ~/openclaw/data/ocas-forge/intake/{decision_id}.json

See spec-ocas-interfaces.md for schemas and handoff contracts.

Mentor reads journals from: ~/openclaw/journals/ (all skills, recursive). This is a read-only scan parallel to Elephas ingestion.

Storage layout

text

~/openclaw/data/ocas-mentor/
  config.json
  projects/
  evaluations/
  ingestion_log.jsonl
  decisions.jsonl
  intake/
    {cycle_id}.json
    processed/
  plans/
    {plan_id}.plan.md
  plan-runs/
    {plan_run_id}/
      state.json
      decisions.jsonl

~/openclaw/journals/ocas-mentor/
  YYYY-MM-DD/
    {run_id}.json

Default config.json:

json

{
  "skill_id": "ocas-mentor",
  "skill_version": "2.3.0",
  "config_version": "1",
  "created_at": "",
  "updated_at": "",
  "heartbeat": {
    "light_interval_minutes": 15,
    "deep_interval_hours": 24
  },
  "evaluation": {
    "minimum_runs_for_promotion": 20,
    "non_regression_required": true
  },
  "retention": {
    "days": 0,
    "max_records": 10000
  }
}

OKRs

Universal OKRs from spec-ocas-journal.md apply to all runs.

yaml

skill_okrs:
  - name: orchestration_success_rate
    metric: fraction of projects reaching completion without manual rescue
    direction: maximize
    target: 0.85
    evaluation_window: 30_runs
  - name: evaluation_coverage
    metric: fraction of skill journals ingested within one heartbeat cycle
    direction: maximize
    target: 0.99
    evaluation_window: 30_runs
  - name: variant_decision_quality
    metric: fraction of promotions not rolled back within 30 days
    direction: maximize
    target: 0.90
    evaluation_window: 30_runs
  - name: repair_escalation_rate
    metric: fraction of failures requiring strategy-level escalation
    direction: minimize
    target: 0.10
    evaluation_window: 30_runs

Optional skill cooperation

• Forge — receives VariantProposal and VariantDecision files via intake directory
• Fellow — invoked by Mentor to run controlled benchmark experiments; returns best variant result
• Elephas — Mentor may read Chronicle (read-only) for evaluation context
• Corvus — Mentor may read Corvus pattern data for anomaly context
• All skills — Mentor reads journals from all skills for evaluation

Journal outputs

Action Journal — every orchestration run, heartbeat pass, variant evaluation, and proposal emission.

Initialization

On first invocation of any Mentor command, run mentor.init:

1. Create ~/openclaw/data/ocas-mentor/ and subdirectories (projects/, evaluations/, intake/, intake/processed/, plans/, plan-runs/)
2. Write default config.json with ConfigBase fields if absent
3. Create empty JSONL files: ingestion_log.jsonl, decisions.jsonl
4. Create ~/openclaw/journals/ocas-mentor/
5. Ensure ~/openclaw/data/ocas-forge/intake/ exists (create if missing)
6. Ensure ~/openclaw/data/ocas-fellow/intake/ exists (create if missing)
7. Copy bundled plans from skill package references/plans/*.plan.md to ~/openclaw/data/ocas-mentor/plans/ -- skip any plan file already present (do not overwrite user-modified plans)
8. Register cron jobs mentor:deep and mentor:update if not already present (check openclaw cron list first)
9. Register heartbeat entry mentor:light in HEARTBEAT.md if not already present
10. Log initialization as a DecisionRecord in decisions.jsonl

Background tasks

Job name	Mechanism	Schedule	Command
mentor:deep	cron	0 5 * * * (daily 5am)	mentor.heartbeat.deep — full OKR scoring, trend analysis, variant proposals
mentor:light	heartbeat	every heartbeat pass	mentor.heartbeat.light — ingest journals, update aggregates, queue work
mentor:update	cron	0 0 * * * (midnight daily)	mentor.update

Cron options for mentor:deep: sessionTarget: isolated, lightContext: true, wakeMode: next-heartbeat.

Registration during mentor.init:

text

openclaw cron list
# If mentor:deep absent:
openclaw cron add --name mentor:deep --schedule "0 5 * * *" --command "mentor.heartbeat.deep" --sessionTarget isolated --lightContext true --wakeMode next-heartbeat --timezone America/Los_Angeles
# If mentor:update absent:
openclaw cron add --name mentor:update --schedule "0 0 * * *" --command "mentor.update" --sessionTarget isolated --lightContext true --timezone America/Los_Angeles

Heartbeat registration: append mentor:light entry to ~/.openclaw/workspace/HEARTBEAT.md if not already present.

Self-update

mentor.update pulls the latest package from the source: URL in this file's frontmatter. Runs silently — no output unless the version changed or an error occurred.

1. Read source: from frontmatter → extract {owner}/{repo} from URL
2. Read local version from skill.json
3. Fetch remote version: gh api "repos/{owner}/{repo}/contents/skill.json" --jq '.content' | base64 -d | python3 -c "import sys,json;print(json.load(sys.stdin)['version'])"
4. If remote version equals local version → stop silently
5. Download and install:

   bash

   TMPDIR=$(mktemp -d)
   gh api "repos/{owner}/{repo}/tarball/main" > "$TMPDIR/archive.tar.gz"
   mkdir "$TMPDIR/extracted"
   tar xzf "$TMPDIR/archive.tar.gz" -C "$TMPDIR/extracted" --strip-components=1
   cp -R "$TMPDIR/extracted/"* ./
   rm -rf "$TMPDIR"
   

6. On failure → retry once. If second attempt fails, report the error and stop.
7. Output exactly: I updated Mentor from version {old} to {new}

Visibility

public

Support file map

File	When to read
references/schemas.md	Before creating projects, tasks, proposals, or decisions
references/orchestration_engine.md	Before goal decomposition, scheduling, or failure repair
references/evaluation_engine.md	Before journal ingestion, OKR scoring, or champion/challenger pairing
references/evolution_engine.md	Before improvement detection, proposal generation, or promotion decisions
references/journal.md	Before mentor.journal; at end of every run
references/workflow_plans.md	Before any mentor.plan.* command
references/plans/template.plan.md	When writing a new plan file
references/plans/contact-enrichment.plan.md	When running the contact enrichment workflow