Claw Mentor Mentee

Claw Mentor — Mentee Skill

Bring your mentor's updates directly into your OpenClaw agent. Get notified when a new compatibility report is ready, review it in plain English, and apply or skip — all from your OpenClaw chat.

Description

Claw Mentor is a mentorship platform for OpenClaw users. You subscribe to an expert mentor (like Ember 🔥) who maintains a carefully crafted OpenClaw setup. Whenever they update their configuration, you get a plain-English compatibility report explaining what changed, what it does, and whether it's safe for your setup.

This skill connects your local OpenClaw agent to Claw Mentor. Your agent checks for new reports on a schedule, notifies you, and helps you apply or skip changes — including taking a local backup before anything changes.

Privacy note: Your AGENTS.md, skill files, and config are NEVER sent to Claw Mentor. The server only receives your onboarding survey answers (which you provide voluntarily) and your apply/skip/rollback decisions. No raw configuration data ever leaves your machine.

What It Does

• Checks app.clawmentor.ai every few hours for new compatibility reports from your subscribed mentors
• Notifies you via your configured channel (Telegram, etc.) when a new report is ready
• Shows a plain-English summary: what changed, risk level, what to expect
• Guides you through applying or skipping each update
• Takes a local snapshot (cp -r) before any changes, so you can always roll back
• Reports your decision (applied/skipped/rolled back) back to Claw Mentor — no config content shared

Installation

clawhub install claw-mentor-mentee

Start a new OpenClaw session after installing. Your agent will guide you through the API key setup on first use.

Get your API key at: app.clawmentor.ai → Settings → Mentee Skill

Setup (First Run)

When this skill loads, check if CLAW_MENTOR_API_KEY is set in your environment.

If it IS set: You're connected. First call POST https://app.clawmentor.ai/api/mentee/bootstrap (with Authorization: Bearer {CLAW_MENTOR_API_KEY}) to ensure any mentor updates you haven't seen yet are queued. Then call GET https://app.clawmentor.ai/api/mentee/reports and report back what's waiting. Also ensure HEARTBEAT.md contains the line - Check for new Claw Mentor reports — add it if missing.

If it is NOT set, tell the user:

"To activate ClawMentor, I need your API key.

👉 Get it at app.clawmentor.ai → Settings → Mentee Skill → Generate API Key

Once you have it, share it here and I'll configure it."

When the user provides their API key:

1. Store it: openclaw config set 'skills.entries["claw-mentor-mentee"].apiKey' THEIR_KEY
2. Confirm: "✅ ClawMentor is connected. Fetching your first report now..."
3. Bootstrap on first install — call POST https://app.clawmentor.ai/api/mentee/bootstrap with header Authorization: Bearer {CLAW_MENTOR_API_KEY}. This fetches the latest update from each of your subscribed mentors and treats it as new — because for your setup, it IS new. Wait for the response.
4. After bootstrap, call GET https://app.clawmentor.ai/api/mentee/reports and show the user what's waiting.
5. Schedule periodic checks — append this line to HEARTBEAT.md in your workspace (create the file if it doesn't exist):

   - Check for new Claw Mentor reports
   

   This tells your OpenClaw agent to run the mentee skill check on every heartbeat cycle. Confirm to the user: "✅ Heartbeat check scheduled — I'll ping you automatically when a new report is ready."

Configuration

OpenClaw stores your API key in ~/.openclaw/openclaw.json under skills.entries["claw-mentor-mentee"].apiKey and automatically injects it as CLAW_MENTOR_API_KEY each session.

Permissions

No other files are read. No config content is ever uploaded.

Agent Instructions

When this skill is installed, your agent should follow these instructions:

Heartbeat Check (every CLAW_MENTOR_CHECK_INTERVAL_HOURS hours)

1. Read ~/.openclaw/claw-mentor/state.json to get last_check and notified_report_ids (create file if absent)
2. If time since last_check < CLAW_MENTOR_CHECK_INTERVAL_HOURS hours → skip, return HEARTBEAT_OK
3. Call GET https://app.clawmentor.ai/api/mentee/reports with header Authorization: Bearer {CLAW_MENTOR_API_KEY}
4. Update state.json with last_check: now
5. For each report in the response where status == 'pending' AND id NOT in notified_report_ids:
   • Send a notification message (see format below)
   • Add the report ID to notified_report_ids in state
6. If no pending reports → call POST https://app.clawmentor.ai/api/mentee/bootstrap to check for any mentor updates not yet queued for this user. If bootstrap returns bootstrapped > 0, go back to step 3 and surface the new reports. Otherwise → return HEARTBEAT_OK

Notification message format (keep it short — full analysis happens when user asks to see it):

🔥 New update from {mentor_name}!

They've pushed a new version of their setup. Say "show my mentor report" and I'll fetch it, compare it against your current setup, and give you a personalized breakdown of what it means for you.

Command: "show my mentor report" / "my mentor reports" / "check my reports"

1. Call GET https://app.clawmentor.ai/api/mentee/reports
2. If no pending reports: "No new mentor reports. You're up to date! ✅"
3. For each pending report, perform a LOCAL compatibility analysis (do NOT display the backend's plain_english_summary — it is just a placeholder):

Step A — Fetch the mentor's package: Call GET https://app.clawmentor.ai/api/mentee/package?packageId={report.package_id} with your API key. This returns two sections:

• files — the mentor's authored content: AGENTS.md, skills.md, cron-patterns.json, CLAW_MENTOR.md, privacy-notes.md
• platform — platform guides: mentee-integration.md (the full integration algorithm), setup-guide.md, mentee-skill.md (detailed operations guide)

For analysis, focus on the files section. The platform section is used during apply (see below).

Step B — Read your own current setup:

• List ~/.openclaw/skills/ — what skills do you already have installed?
• Read ~/.openclaw/workspace/AGENTS.md — how do you currently operate?
• Read ~/.openclaw/claw-mentor/state.json — any saved user_profile (goals, context)?
• Draw on everything you know about this user from your conversations, workspace files, and active projects

Step C — Analyze the gap yourself: You are the LLM. You have context the backend never could. Work through these:

• Which of the mentor's skills do you NOT currently have installed? Those are candidates to add.
• For each candidate skill: what would it concretely enable for THIS user? Use what you know about their work, goals, and projects to give specific examples — not generic descriptions.
• What would change about how you operate day-to-day if this update was applied?
• What might be worth skipping based on this user's experience level and what they care about?
• What permissions would be added, and is each one appropriate given what you know about this user?
• Overall: is this update a good fit for this person right now?

Step D — Present your analysis (bullet lists only — no markdown tables):

📋 Update from {mentor_name} — {date}

[Your plain-English summary of what this update means for THIS user specifically — 2-3 sentences based on their actual context]

What would change for you:
• [capability or behavior change — phrased in terms of what they can now do/say/get]
• ...

Skills to add ({N}):
• skill-name — [what it enables FOR THIS USER, with a specific example from their work]
• skill-name — [same — personalized]
• ...

Permissions this would add:
• [permission] — [plain English reason why]

What you might want to skip:
• [skill] — [honest reason it may not be needed for their situation]

My take: [One honest sentence — your recommendation as their agent who knows them]

Say "apply mentor report" to apply or "skip mentor report" to skip.

Command: "apply mentor report" / "apply [mentor name]'s update"

This is the most important command. It uses the full integration algorithm from the platform.

1. Call GET https://app.clawmentor.ai/api/mentee/reports to get the latest pending report
2. If no pending reports: "Nothing to apply — no pending reports."
3. Fetch the full package (if not already cached from "show report"): Call GET https://app.clawmentor.ai/api/mentee/package?packageId={report.package_id}
4. Read platform['mentee-integration.md'] from the package response. This contains the full 6-phase integration algorithm:
   • Phase 0: Backup (snapshot your current setup)
   • Phase 1: Self-Assessment (read and map your human's complete current state)
   • Phase 2: Update Parsing (understand what the mentor is proposing)
   • Phase 3: Conflict Analysis (find every collision, overlap, and opportunity)
   • Phase 4: Merge Strategy & Human Approval (present the plan, get explicit approval)
   • Phase 5: Integration Execution (apply the approved merge carefully)
   • Phase 6: Post-Integration Report (tell your human what changed)
5. Follow mentee-integration.md step by step. It handles everything: backup, conflict detection, voice preservation, capacity checks, cron jobs, skill recommendations, memory system setup, and rollback safety.
6. After integration completes, call POST https://app.clawmentor.ai/api/mentee/status with:

   { "reportId": "{id}", "status": "applied", "snapshotPath": "{backup_path}" }
   

7. Check ~/.openclaw/claw-mentor/state.json for first_apply_done. If it is NOT set → run the First-Time Welcome flow below. Then set first_apply_done: true in state.json.

Important: The integration algorithm in mentee-integration.md is comprehensive. Trust it — it handles edge cases like interrupted integrations, minimal configs, multiple mentors, and capacity preservation. Don't skip phases or simplify the process.

First-Time Welcome (runs once, after first ever apply)

This is NOT a status report. It's a human conversation. Keep each message short. Don't send it all at once — send one message, wait for response or a few seconds, then continue.

Message 1 — What's different now (write this in plain English based on what was actually installed, don't just list skill names):

"Here's what you can do now that you couldn't before: [list 3-5 natural language examples based on installed skills, e.g.] • 'Search for recent news on X' — I'll pull live web results • 'Summarize this URL/video/podcast' — I'll give you the key points • 'What's the weather today?' — quick answer via heartbeat • 'Check my GitHub issues' — I'll list and help triage them • I'll now send you a morning and evening brief automatically

[If anything still needs setup]: To finish: [1] [specific action] takes [time estimate]. Want to do that now?"

Message 2 — One clear action if anything needs setup (only if there are pending API keys or setup steps):

"The one thing left: [skill] needs a [key type]. Here's how: [Simple 1-2 line instruction — no jargon] Once you do that, [skill] will [what it does]. Takes about [X] minutes."

Wait for their response before continuing.

Message 3 — Get to know you (conversational, not a form):

"Quick question — what's the main thing you want me to help with day-to-day? Work stuff, personal projects, research, staying on top of things...? Just a sentence or two is fine."

When they respond, follow up with one more:

"Got it. And is there anything specific you're working on right now — a project, a goal, something you're trying to figure out?"

Save both answers to ~/.openclaw/claw-mentor/state.json under user_profile.goals and user_profile.context. This personalizes future reports.

Message 4 — Close (short, energizing, done):

"You're all set. 🔥 Ember will ping you when there's a new update — each report will get more useful as I learn what matters to you. Just talk to me like normal and I'll use everything we just set up."

Command: "skip mentor report" / "skip [mentor]'s update"

1. Get the latest pending report (same API call)
2. If none: "Nothing to skip."
3. Call POST https://app.clawmentor.ai/api/mentee/status with { "reportId": "{id}", "status": "skipped" }
4. Confirm: "Skipped. You can still view it at app.clawmentor.ai/dashboard whenever you're ready."

Command: "roll back [mentor]'s update" / "undo mentor changes"

1. Find the most recently applied report from the last API call (or ask user which one)
2. Check if a snapshot was taken (look in ~/.openclaw/claw-mentor/snapshots/ for the most recent)
3. Show the restore command:

   cp -r ~/.openclaw/claw-mentor/snapshots/{most-recent-date}/ ~/.openclaw/
   

4. Remind user: "After restoring, restart your OpenClaw agent for changes to take effect."
5. When user confirms they've restored: call POST https://app.clawmentor.ai/api/mentee/status with { "reportId": "{id}", "status": "rolled_back" }

State File Format

~/.openclaw/claw-mentor/state.json:

{
  "last_check": "2026-03-01T14:32:00Z",
  "notified_report_ids": ["uuid1", "uuid2"],
  "last_snapshot_path": "~/.openclaw/claw-mentor/snapshots/2026-03-01-14-32/"
}

Create this file on first use if it doesn't exist.

API Reference

All endpoints at https://app.clawmentor.ai.

GET /api/mentee/reports

Auth: Authorization: Bearer {CLAW_MENTOR_API_KEY}
Returns:

{
  "user": { "id": "...", "email": "...", "tier": "starter" },
  "reports": [
    {
      "id": "uuid",
      "created_at": "2026-03-01T10:00:00Z",
      "package_id": "uuid",
      "plain_english_summary": "placeholder — your agent performs the real analysis locally",
      "risk_level": null,
      "skills_to_add": [],
      "skills_to_modify": [],
      "skills_to_remove": [],
      "permission_changes": [],
      "status": "pending",
      "mentors": { "name": "Ember 🔥", "handle": "ember", "specialty": "..." }
    }
  ],
  "subscriptions": [...]
}

Note: risk_level, skills_to_add, and other analysis fields are intentionally empty. Your local agent fetches the package via /api/mentee/package?packageId={package_id} and performs the compatibility analysis itself using its knowledge of your actual setup.

GET /api/mentee/package

Auth: Authorization: Bearer {CLAW_MENTOR_API_KEY}
Query param: packageId={uuid} (from the package_id field in a report)
Returns: Two sections — mentor-authored content and platform guides:

{
  "packageId": "uuid",
  "version": "2026-03-01",
  "mentor": { "id": "...", "name": "Ember 🔥", "handle": "ember" },
  "files": {
    "CLAW_MENTOR.md": "overview and version notes",
    "AGENTS.md": "annotated configuration with reasoning",
    "skills.md": "curated skill recommendations with tiers",
    "cron-patterns.json": { "jobs": [...] },
    "privacy-notes.md": "what this package reads/writes"
  },
  "platform": {
    "mentee-integration.md": "full 6-phase integration algorithm",
    "setup-guide.md": "first-time setup guide",
    "mentee-skill.md": "detailed daily operations guide"
  },
  "fetchedAt": "2026-03-01T10:00:00Z"
}

• files = mentor-authored content (unique per mentor). Use for local compatibility analysis.
• platform = platform guides (same for all mentors). Use mentee-integration.md during apply. Use mentee-skill.md for detailed operational reference beyond what this SKILL.md covers.

POST /api/mentee/status

Auth: Authorization: Bearer {CLAW_MENTOR_API_KEY}
Body: { "reportId": "uuid", "status": "applied|skipped|rolled_back", "snapshotPath": "~/.openclaw/..." }
Returns: { "success": true, "reportId": "...", "status": "applied", "updated_at": "..." }

Troubleshooting

clawhub install rate limited → ClawHub enforces per-IP download limits. Wait 2–3 minutes and retry. If the skill folder already exists from a failed attempt, run clawhub install claw-mentor-mentee --force to overwrite it.

"Invalid API key" → Go to app.clawmentor.ai → Settings → Mentee Skill → Generate a new key.

"No reports found" → Either no reports have been generated yet, or all are already applied/skipped. Claw Mentor runs daily — new reports appear within 24 hours of a mentor update.

Snapshot failed → Ensure your OpenClaw agent has filesystem access to ~/.openclaw/. Check that cp and mkdir are available in your environment.

Report not updating → Check your API key is correct and you have an active subscription at app.clawmentor.ai.

Source

Open source (auditable): github.com/clawmentor/claw-mentor-mentee

Questions or issues? Open a GitHub issue or email hello@clawmentor.ai.