OutClaw , Style

learns your writing style per outreach channel (email, LinkedIn, Twitter/X, WhatsApp, Slack, SMS, Discord, Telegram, etc.) and persists it as a reusable prompt. the skill runs the Prompt Learning Protocol on ≥20 outbound samples per channel, extracts patterns (sentence length, tone, structure, anti-patterns), and generates a 500-2000 word style guide. use this when you want to audit your voice across channels, or let outclaw-plan auto-invoke it silently whenever a planned channel lacks a trained style. the learned prompt lives at ~/.openclaw/outclaw/styles/<tenant>/<channel>_style.md so downstream drafting tools can adopt your authentic voice without manual tone specification.

intent

learns the user's authentic writing style per channel by analyzing outbound message samples, then distills that style into a reusable prompt guide. this skill runs on explicit user request ("learn my style", "retrain style for email") or auto-invokes silently when outclaw-plan builds a draft plan that includes a channel with no trained style. the output is a markdown file with actionable instructions (not generic tone advice) that outclaw-plan consumes directly for message generation. use this to ensure all outreach sounds like you, even across 8+ channels, without asking the user to describe their own voice.

inputs

plugins and connections (read from capability map capabilities/<tenant>.json; skill enumerates only ready channels):

• Gmail: gog gmail messages search "from:me" --max 50 (native tool)
• LinkedIn: linkedin-cli posts --author me --max 50 (or user export if not connected)
• Twitter/X: XActions or direct API via xurl
• Slack: slack-mcp-server message history where sender=me
• WhatsApp: whatsapp-mcp-ts conversation export, filter author=me
• Telegram: telegram-mcp sent messages
• Discord: discord-mcp messages where author=me
• iMessage/SMS: mac_messages_mcp sent messages
• Bluesky: bsky-mcp-server user posts

memory and context:

• tenant ID (from skill context or environment)
• tool_inventory memory entry (lists connected plugins)
• style_consent preference entry (opt-in flag, set during outclaw-setup Step 2; required unless user confirms consent inline during explicit invocation)
• existing style files at styles/<tenant>/*_style.md (to detect if retraining)

external script references:

• scripts/message_classifier.py: two-stage heuristic + LLM classifier (OUTREACH_COLD/FOLLOWUP/WARM vs. NOT_OUTREACH)
• scripts/style_evaluator.py: 5-iteration Prompt Learning Protocol with test generation, scoring, refinement
• references/style-learning.md: detailed protocol steps
• agents/style-learner.md: delegated sub-agent spec

rate limits and auth edge cases:

• Gmail API: 10 queries per second, 250K per day quota. if hit, fall back to cached recent messages or defer retraining.
• LinkedIn, Twitter/X, Discord: per-API rate limits. log observation if sample pull times out or hits 429.
• Telegram/WhatsApp: may require active session or OAuth token refresh. if auth expired, log observation and skip channel.
• Slack: workspace token scopes must include channels:history and groups:history for DM/channel scraping. if missing, skip.

procedure

step 1: resolve invocation context.

• input: skill request (explicit user prompt or auto-invoke flag from outclaw-plan).
• check if auto-invoked: if yes, extract the single <channel> parameter. if explicit, extract channel list (or assume all ready channels).
• check style_consent memory entry. if missing and explicit invocation, ask user once: "sample your outbound messages to learn your style. ok?" if no, log observation, skip to step 6. if yes, record {type: preference, key: style_consent, value: true}. if auto-invoked and no consent, log observation {key: "style_no_consent", insight: "auto-invoke blocked; user has not opted in"}, fall back to neutral template, return to caller.
• output: channel list, consent status, invocation type (explicit or auto).

step 2: enumerate and validate channels.

• input: channel list, capability map.
• filter to channels that are ready in capabilities/<tenant>.json and have a sample source defined (see inputs table).
• skip channels with no connected plugin (log as skipped).
• output: validated channel list (e.g. [gmail, slack, twitter]).

step 3: pull outbound samples per channel (parallelize if possible).

• for each validated channel:
  • use the channel's plugin (from inputs table) to fetch ≥20 recent outbound messages. sort by date descending, take the most recent batch.
  • write raw samples to kb/raw/style-<tenant>-<channel>-<timestamp>.jsonl (one JSON object per line: {id, body, timestamp, platform}). do not mutate or filter yet.
  • count samples and words. if sample count <20 or total word count <1000, log observation: {type: observation, key: style_thin_<channel>, insight: only <N> samples / <W> words, learned prompt confidence will be lower, source: observed, confidence: 6}. proceed anyway.
  • if sample count == 0 (e.g. fresh channel, no outbound history), log observation: {type: observation, key: style_nosamples_<channel>, insight: no outbound samples on <channel>; using neutral template, source: observed, confidence: 6}. skip to step 3b for this channel.
  • output per channel: raw samples file path, sample count, word count, observation (if thin or zero).

step 3a: classify messages (for channels with ≥1 sample).

• input: raw samples from step 3.
• run heuristic pre-filter: exclude auto-replies, trivial length (<10 words), system messages.
• run scripts/message_classifier.py (LLM + heuristic): classify each message as OUTREACH_COLD, OUTREACH_FOLLOWUP, OUTREACH_WARM, or NOT_OUTREACH (e.g. internal chat, personal notes).
• retain only OUTREACH_* messages. if <20 outreach messages remain, log observation with revised sample count.
• output: classified, filtered message set per channel.

step 3b: run Prompt Learning Protocol (5 iterations, per channel).

• input: filtered message set (or empty set if no samples).
• if message set is empty, skip iterations and emit neutral template (see step 5b).
• if message set is non-empty:
  • iteration 1-5 loop (see scripts/style_evaluator.py for implementation):
    • iteration start: set temperature to 0.8 (high creativity).
    • generate: prompt the LLM to write 3-5 test messages in the user's style based on current prompt draft (iter 1: seed with "direct, concise, warm-professional" + sample analysis).
    • evaluate: score each test message against 8 dimensions (sentence_length, formality, personalization, cta_style, structure, tone, greeting_pattern, signoff_pattern) using LLM judges (0-100 per dimension). average per test message.
    • track: record best score this iteration, best test message.
    • refine (if iteration < 5): lower temperature to 0.4 (focus). identify lowest-scoring 2-3 dimensions. rewrite prompt to address them (e.g. if formality is too high, add "avoid corporate jargon").
    • record: log {iter: <N>, score: <avg_score>, dimensions: {sentence_length: <X>, ...}}.
  • after iteration 5: select best_iteration (the iter with highest avg score) and best test message as exemplar.
  • output: learned prompt (500-2000 words, Instructions + Avoid sections), best_score, best_iteration, dimensions array, conformity_log (all 5 iter scores).

step 4: write learned style file.

• input: learned prompt (or neutral template if no samples), best_score, best_iteration, sample count, dimensions, conformity_log, channel, tenant.
• location: ~/.openclaw/outclaw/styles/<tenant>/<channel>_style.md (never kb/styles/* or kb/me/styles/*).
• frontmatter: tenant, channel, trained_at (ISO 8601 timestamp), sample_count, best_score, best_iteration, dimensions (array), conformity_log (array of {iter, score} objects).
• body: markdown with ## Instructions (the learned prompt, actionable and direct), ## Avoid (list of anti-patterns the user avoids), ## Reference samples (pointer to the raw .jsonl file, not verbatim dump).
• output: file written to disk.

step 5: update memory (tenant KB).

• input: channel, best_score, sample_count.
• record: {type: user, key: style_trained_<channel>, insight: "<channel> style trained; score <best_score>/100; <sample_count> samples", source: observed, confidence: <best_score/10>}.
• output: memory entry persisted.

step 6: report to user (if explicit invocation) or return silently (if auto-invoke).

• input: invocation type, all channels processed, their best_scores and sample_counts.
• if explicit: format compact report: "trained (score 82, 42 samples), (score 71, 18 samples). thin data on ."
• if auto-invoke: return silently to outclaw-plan.
• output: user-facing report (explicit) or return status code (auto).

decision points

consent check (step 1):

• if style_consent memory entry exists and true, proceed.
• if missing and explicit invocation, ask user once. record decision. if user declines, skip sample collection and return to step 6 with no-consent message.
• if missing and auto-invoked, log observation, fall back to neutral template (step 3b), skip sample pull, return to caller. never silently scrape without consent.

channel readiness (step 2):

• if channel is not ready in capability map, skip it entirely (no plugin available).
• if channel is ready but plugin call times out or returns 401/403, log observation and skip that channel. proceed with others.

sample sufficiency (step 3):

• if sample count >= 20 and word count >= 1000, proceed to classification at normal confidence.
• if sample count < 20 or word count < 1000, log thin-data observation, proceed anyway (best-score will be marked lower confidence).
• if sample count == 0, log zero-samples observation, emit neutral template, skip to step 5 for that channel.

outreach classification (step 3a):

• if <20 messages classified as OUTREACH_*, log revised sample count observation. if 0 outreach messages, treat as zero-sample case (neutral template).
• if ≥20 outreach messages, proceed to iteration loop.

iteration refinement (step 3b):

• after each iteration, if best_score on current iteration is higher than previous best, update best_iteration and continue. if iteration 5 completes, stop (do not loop beyond 5).
• if best_score plateaus or declines for 2 consecutive iterations, optionally stop early (log as early-termination observation). this is an implementation detail in scripts/style_evaluator.py.

neutral template fallback (step 3b, 4):

• if no outbound samples exist OR zero outreach messages after classification, emit a minimal neutral template:

  ---
  tenant: <tenant>
  channel: <channel>
  trained_at: <ISO 8601>
  sample_count: 0
  best_score: null
  best_iteration: null
  dimensions: []
  conformity_log: []
  ---
  
  # <channel> style ,  <tenant>
  
  ## Instructions
  Write in a direct, warm, professional tone. Keep sentences concise (12-18 words average).
  Personalize the opening. End with a single, clear call-to-action.
  
  ## Avoid
  - corporate jargon
  - unnecessary formality
  
  ## Reference samples
  No outbound samples available.
  

  mark confidence as 6/10 in memory.

auto-invoke return (step 6):

• if auto-invoked from outclaw-plan, do NOT ask user for feedback. return control to caller immediately after step 5 (memory update). outclaw-plan resumes message drafting.
• if explicit invocation, show user the compact report and offer "retrain " option.

output contract

style prompt file:

• location: ~/.openclaw/outclaw/styles/<tenant>/<channel>_style.md (one file per channel per tenant).
• format: markdown with YAML frontmatter (tenant, channel, trained_at, sample_count, best_score, best_iteration, dimensions, conformity_log).
• body: ## Instructions section (500-2000 words, actionable style guide), ## Avoid section (bulleted anti-patterns), ## Reference samples section (pointer to raw .jsonl file).
• validity: file must be readable by outclaw-plan's style prompt parser (expects YAML frontmatter + markdown body).

raw samples archive:

• location: kb/raw/style-<tenant>-<channel>-<timestamp>.jsonl (JSONL, one message per line).
• format: {id, body, timestamp, platform, classified_as} (e.g. "OUTREACH_COLD").
• retention: kept for audit trail and potential future retraining.

memory entry:

• location: tenant memory (type=user).
• key: style_trained_<channel>.
• value: {insight: "<channel> style trained; score <X>/100; <N> samples", source: observed, confidence: <X/10>}.
• used by: outclaw-plan for quick lookup (does this channel have a trained style?).

error/observation logging:

• location: tenant memory (type=observation).
• keys: style_thin_<channel> (if <20 samples), style_nosamples_<channel> (if 0 samples), style_no_consent (if consent missing on auto-invoke), style_auth_failed_<channel> (if plugin auth expired), etc.
• used by: user (in memory browser) and downstream skills for context.

outcome signal

explicit invocation (user says "learn my style"):

• user sees compact report: "trained email (score 82/100, 42 samples), slack (score 71/100, 18 samples , thin data). discord skipped (no plugin). check memory for details."
• files written: styles/<tenant>/email_style.md, styles/<tenant>/slack_style.md, etc.
• memory updated: style_trained_email, style_trained_slack, and any style_thin_* observations.
• user can then inspect ~/.openclaw/outclaw/styles/<tenant>/*_style.md to read the learned Instructions and Avoid sections.

auto-invoke (outclaw-plan calls during draft planning):

• no user-facing output during skill execution (silent).
• files written to styles/<tenant>/<channel>_style.md before outclaw-plan resumes.
• memory updated with style_trained_<channel> entry.
• outclaw-plan detects file exists on retry, parses Instructions section, and uses it in message generation prompt.
• if a user later checks memory or browses /styles/<tenant>/, they see the trained style file and know the channel was auto-styled.

failure cases (user knows something went wrong):

• consent denied: "can't learn your style without permission. reply 'ok' to opt-in."
• no samples on a channel: memory observation logged; neutral template file written (sample_count: 0).
• plugin auth expired: observation logged (e.g. style_auth_failed_slack); channel skipped; user prompted to reconnect plugin.
• rate limit hit: observation logged; skill defers retraining or uses cached samples; user sees "rate limit hit; retrain again in 1 hour."