What makes Openclaw_Teach notable?

1.7K downloads. Trust evidence available

How should Openclaw_Teach be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Openclaw_Teach

Record a screen demonstration and turn it into a reusable, parameterized OpenClaw SKILL.md. Skill: Openclaw_Teach Owner: aldow3n-a11y Summary: Record a screen demonstration and turn it into a reusable, parameterized OpenClaw SKILL.md. Tags: latest:0.1.0 Version history: v0.1.0 | 2026-08-12T13:53:27.729Z | auto - Initial release of the "teach" skill: record a screen demonstration and generate a reusable, parameterized OpenClaw skill file from it. - Handles both video-only and optional narrated demonstrations

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.7k

Updated

Oct 10, 2026

Version

0.1.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.7K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.7K downloadsadoption · observed Oct 10, 2026
Latest release: 0.1.0release · observed Aug 12, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s177373rhj19spch3673evsqnd885c4v:grokbot-inspired-teach-as-openclaw-skill

Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-aldow3n-a11y-grokbot-inspired-teach-as-openclaw-skill/snapshot"

Documentation

CLAWHUB

21,861 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: teach
description: Record a screen demonstration and turn it into a reusable, parameterized OpenClaw SKILL.md.
version: 1.0.0
metadata:
openclaw:
requires:
bins:
- ffmpeg
anyBins:
- python3
- python
emoji: "\U0001F3A5"
---

# Teach — demonstrate a workflow, get a reusable skill

Use this skill when the user wants to capture a screen demonstration and turn it
into a new OpenClaw skill. Everything runs locally on the user's machine; no
cloud computer is involved.

## Steps

1. **Agree the goal.** Ask the user, in one sentence, what result they are about
to demonstrate. Confirm before recording.

2. **Record.** First ask the user whether they want to **narrate** the demo
(speak the intent out loud as they go). Narration is optional and
consent-gated — never record microphone audio without an explicit yes.

- **No narration:** `python3 "{baseDir}/scripts/record.py" "<output.mp4>"`
- **With narration:** add `--with-audio`
(`--audio-device "Name"` only if auto-detect picks the wrong mic).

Default cap is 600s (10 min), matching Grok Bot's Teach limit. Pass a
`max_seconds` arg to change the cap (e.g. `300`). The script records the
primary display cross-platform (Windows `gdigrab`, macOS `avfoundation`,
Linux `x11grab`) and, with `--with-audio`, the microphone (Windows `dshow`,
macOS `avfoundation`, Linux `pulse`). It prints the ffmpeg PID, an `AUDIO
on/off` flag, and the final duration. It stops on Ctrl-C or when the cap is
reached. Tell the user to perform the workflow once, then stop the recording
(Ctrl-C) or let it hit the cap.

3. **Sanity-check.** Run:

```bash
python3 "{baseDir}/scripts/frames.py" "<output.mp4>" --check
```

This writes two frames (≈20% and ≈70% of duration) and reports their paths
and the duration. Look at both frames. If they show an idle desktop or the
wrong surface, the capture is bad: tell the user, offer a redo, and — if they
decline — delete the recording. Do not proceed to transcription on a bad
capture.

4. **Transcribe.** Run:

```bash
python3 "{baseDir}/scripts/frames.py" "<output.mp4>"
```

It extracts evenly spaced frames (and splits the video losslessly if it
exceeds ~12MB so each part stays under attachment limits) and prints the
frame/part paths. Use your own vision to analyze them and produce a
structured play-by-play:

- Starting state (page/app open)
- Every meaningful action in order (clicks, typing, navigation, URL changes,
menus, scrolling)
- Ending state
- Approximate timing
- Exact non-secret text typed — **NEVER** transcribe passwords, one-time
codes, API keys, financial account numbers, or private personal details;
use placeholders

If you have no vision capability, ask the user for a written step list
instead.

**Narration (only if `--with-audio` was used).** Run:

```bash
python3 "{baseDir}/scripts/transcribe.py" "<output.

README.md

# GrokBot-inspired TEACH as an OpenClaw Skill

> Record a screen demonstration on your own machine and turn it into a reusable,
> parameterized OpenClaw `SKILL.md` — no cloud computer required.

## Why

xAI's Grok Bot ships a **"Teach a task"** feature: you demonstrate a workflow on
its persistent cloud computer, and it writes a reusable skill. This project
reimplements that pipeline **natively in OpenClaw**, so capture, transcription,
and skill authoring all happen locally. The output is a standard
[AgentSkills](https://agentskills.io)-format `SKILL.md` you can install, version,
and share.

## What it does

1. Records your screen (and optionally your narration) with `ffmpeg`.
2. Sanity-checks the capture (idle / blank-surface detection).
3. Transcribes the demo — vision over extracted frames, plus optional Whisper
   narration.
4. Cross-checks visited URLs against Chrome's history (optional, consent-gated).
5. Writes a new, parameterized `SKILL.md` into your OpenClaw workspace.
6. Cleans up the recording.

## Install

```bash
# from this repo (replace the slug with your fork if you forked)
openclaw skills install git:aldow3n-a11y/grokbot-inspired-teach-as-openclaw-skill

# or just copy the folder into your workspace skills root
#   ~/.openclaw/workspace/skills/teach/
```

Requirements:

- `ffmpeg` on `PATH` (records the screen).
- `python3` for the helper scripts.
- Optional: `openai-whisper` for narration transcription
  (`pip install openai-whisper`). Without it, the skill falls back to a written
  narration from you.

## Use

```
/teach
```

The skill will:

- Ask what you are about to demonstrate (and whether to narrate).
- Record (default ~10 min cap). Stop with Ctrl-C or let it hit the cap.
- Sanity-check, then transcribe via vision (and Whisper if audio was captured).
- Write a draft `SKILL.md` to `~/.openclaw/workspace/skills/<slug>/` and report.

It never runs the learned skill unprompted, and never embeds credentials.

## Narration script

If you narrate the demo, the generated skill embeds a `## Narration script`
section — your spoken cues, parameterized with `{placeholders}` — so reruns
prompt you with the same intent (or let you adapt it).

## Files

```
teach/
├── SKILL.md                      # the skill (orchestration instructions)
├── scripts/
│   ├── record.py                 # cross-platform ffmpeg recorder (opt-in audio)
│   ├── frames.py                 # frame extractor + lossless splitter
│   └── transcribe.py             # Whisper narration transcription
├── references/
│   ├── skill-schema.md           # OpenClaw SKILL.md schema cheat sheet
│   └── teach-principles.md       # rules every generated skill follows
├── README.md
├── LICENSE
└── .gitignore
```

## Teach principles

Every generated skill follows these rules:

- **Sanity-check first** — drop a bad (idle/blank) capture before transcribing.
- **Redact secrets** — never transcribe or store passwords, OTPs, keys, or
  private details; use placeholders.
- **Paramete

_meta.json

{
  "ownerId": "kn78egvrymnfb5bdv9d4297gp981fse9",
  "slug": "grokbot-inspired-teach-as-openclaw-skill",
  "version": "0.1.0",
  "publishedAt": 1786542807729
}

references/skill-schema.md

# OpenClaw SKILL.md schema (cheat sheet)

OpenClaw skills are folders containing a `SKILL.md` file. OpenClaw follows the
[AgentSkills](https://agentskills.io) spec. Use this when authoring a skill from
a Teach demonstration so the result loads and validates.

## Minimal file

```markdown
---
name: my-skill
description: One-line summary shown to the agent and in discovery (<160 chars).
---

# Title
Markdown instructions telling the agent *what* to do.
```

## Required frontmatter

| Field         | Rule                                              |
| ------------- | ------------------------------------------------- |
| `name`        | 1–64 chars, lowercase letters/digits/hyphens     |
| `description` | One line, under 160 characters                   |

## Optional frontmatter

| Field                    | Default | Notes                                         |
| ------------------------ | ------- | --------------------------------------------- |
| `version`                | —       | Semver string                                 |
| `homepage`               | —       | URL shown in Skills UI                        |
| `user-invocable`         | `true`  | Expose as a slash command (`/<name>`)        |
| `disable-model-invocation` | `false` | Keep instructions out of the system prompt   |
| `command-dispatch`       | —       | Set `"tool"` to route slash cmd straight to a tool |
| `command-tool`          | —       | Tool name when `command-dispatch: tool`       |
| `command-arg-mode`       | `"raw"` | Arg forwarding for tool dispatch              |
| `metadata.openclaw`      | —       | Gating/runtime metadata (see below)           |

## Gating under `metadata.openclaw`

| Key                | Type       | Meaning                                         |
| ------------------ | ---------- | ----------------------------------------------- |
| `requires.bins`    | `string[]` | All binaries must exist on `PATH`              |
| `requires.anyBins` | `string[]` | At least one must exist on `PATH`              |
| `requires.env`     | `string[]` | Each env var must be present                    |
| `requires.config`  | `string[]` | Each `openclaw.json` path must be truthy        |
| `primaryEnv`       | `string`   | Main credential env var                         |
| `envVars`          | `array`    | `{name, required, description}` per var         |
| `always`           | `boolean`  | Skip all gates, always include                  |
| `skillKey`         | `string`   | Override the invocation key                     |
| `emoji`            | `string`   | Display emoji                                    |
| `homepage`         | `string`   | URL                                             |
| `os`               | `string[]` | `["darwin"]` / `["linux"]` / `["win32"]`         |
| `install`          | `array`    | brew/node/go/uv/download dependency specs        |

## Body rules

- Instruct the model on **what** to do, not how to be an AI.
- Reference in-sk

references/teach-principles.md

# Teach principles (applied to every generated skill)

These rules are enforced by the `teach` skill when it turns a screen
demonstration into a new OpenClaw `SKILL.md`. They are derived from Grok Bot's
"Teach a task" pipeline.

1. **Sanity-check the capture first.** Extract one frame at ~20% and one at
   ~70% of duration. If they show an idle desktop or the wrong surface, the
   capture is bad — tell the user and offer a redo; do not transcribe.

2. **Redact secrets.** Never transcribe passwords, one-time codes, API keys,
   financial account numbers, or private personal details. Use placeholders in
   any summary or skill body. If the demonstration was mostly entering
   credentials, say so and **do not create a skill**.

3. **Parameterize.** Separate INPUTS (search term, recipient, date, account)
   from fixed constants. The generated skill uses `{placeholders}` for inputs.

4. **Prefer stable targets.** Reference URLs, labeled buttons, and form fields
   by name/aria, not screen coordinates.

5. **Prefer connectors/MCP over UI replay.** When a connector or MCP tool covers
   a step, use it. Use the browser only for steps nothing else supports.

6. **Confirm consequential steps.** Mark orders, messages, payments, deletions,
   and production changes as **confirm with the user first**.

7. **No embedded credentials.** Sign-in state lives in the browser profile, so a
   step needing login says "assumes signed in to X". Never store secrets in the
   skill body.

8. **The skill is a draft.** Tell the user to add decision rules, failure
   handling, and approval boundaries that may not be obvious from one example,
   and to test on a safe example before scheduling.

9. **Clean up.** Delete the recording and all extracted frames/parts after the
   skill is written. Never leave recordings on disk.

## Narration (optional)

Narration is captured only with explicit consent (`--with-audio`). It enriches
the play-by-play with intent but is never required. Whisper transcription is
best-effort: if it is not installed, fall back to a written narration from the
user. Spoken secrets are redacted exactly like typed ones — placeholders only.

When authoring the skill, capture the spoken cues as a parameterized
`## Narration script` section so reruns prompt the user with the same intent.
Replace concrete values (names, dates, account IDs) with `{placeholders}`; keep
each cue to one line. The generated skill presents this script to the user on
every run.

Github ReposUpdated 12h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.