Meta Workflow Discoverer

AI-powered workflow automation discoverer that observes user patterns, identifies repetitive tasks, and automatically generates executable automation workflo...

Security Scan

The skill's documentation claims background observation, cross-user learning, scheduling and ML-driven discovery, but the included code is a local recorder/analyzer that writes to ~/.workflow_discoverer and does not implement the advertised background observation, sharing, or obvious ML dependencies — several features are overstated or unexplained.

Purpose & Capability

The SKILL.md describes an agent that "observes user patterns", performs cross-user learning, scheduling, and ML-driven automation. The Python code provided implements a local recorder, simple sequence/time aggregation, and basic heuristics for discovering workflows. There is no code shown that "observes" system activity automatically, performs networked cross-user learning, or uses ML libraries. The install instruction (pip install numpy pandas scikit-learn) is inconsistent with imports in the code (no numpy/pandas/sklearn imports in the visible file). This suggests the README overstates capabilities or the implementation is incomplete.

Instruction Scope

SKILL.md implies continuous observation, scheduled/event triggers, automatic automation execution, and cross-user sharing. The runtime instructions and API surface in the README focus on explicit calls (record_task, import_history, discover_workflows, create_automation). There are no instructions or code shown that instruct the agent to read system logs, monitor user activity, integrate with external services, or contact remote endpoints. This is scope creep: the declared behavior (automatic observation, cross-user learning) is not realized by the available code/instructions.

Install Mechanism

There is no packaged install spec in the registry metadata (instruction-only skill) but SKILL.md tells users to 'pip install numpy pandas scikit-learn'. The provided Python file does not import these libraries in the visible portion, so the recommended heavy dependencies are disproportionate to the shown implementation. This could be benign (leftover docs) but is an inconsistency worth flagging.

Credentials

The skill declares no required environment variables or credentials, and the code similarly shows no network calls or credential usage in the visible portion. However, SKILL.md claims features like 'Cross-User Learning' which would normally require network access and credentials — yet none are requested. That mismatch is suspicious: either sharing is not implemented, or the skill will later be modified to contact external services (which would require credentials) without prior declaration.

Persistence & Privilege

The code persists user data to a file under the user's home (~/.workflow_discoverer/{user_id}.json). This is consistent with 'discoverer' functionality but means the skill will store potentially sensitive task history locally. The skill is not set to always:true and requests no special runtime privileges. Writing to the user's home directory is expected but should be noted because it creates a local datastore of user activity.

What to consider before installing

This skill's README promises automatic observation, cross-user learning, scheduling, and ML-powered discovery, but the included code implements a simple local recorder and heuristic pattern detection that runs only when you call its APIs and stores data in ~/.workflow_discoverer/{user_id}.json. Before installing or enabling it: - Expectation mismatch: don't assume it will monitor your activity in the background or share data across users — the files show no network or background-monitoring code in the visible portion. If those features are required, ask the author for the full implementation or for explicit network endpoints and privacy guarantees. - Local storage: it will create and write a JSON file in your home directory containing recorded task history; this may include sensitive task names, contexts, or parameters. Review that file and consider running the skill in a sandbox or with non-sensitive test data first. - Dependency note: SKILL.md suggests installing numpy/pandas/scikit-learn but the visible code doesn't use them. Avoid installing unnecessary packages unless you confirm they are actually required (or inspect the remainder of the code). - Audit recommendation: inspect the rest of workflow_discoverer.py (it was truncated) for any network calls, remote endpoints, or code that imports ML libraries or spawns processes. If you see any outbound HTTP requests, credential usage, or obfuscated code paths, do not enable autonomous invocation and run it in an isolated environment. What would change this assessment: if the remainder of the code contains justified ML usage (and the SKILL.md's install line matches imports), or if there are explicit, declared, and reasonable mechanisms for cross-user learning (with explicit endpoints and credential requirements), that would make the skill more coherent. Conversely, if hidden network calls or credential harvesters appear in the truncated portion, the risk would be higher.

Automatically discover and create workflows from patterns.

Features

1. Pattern Mining

• Task Similarity: Find similar recurring tasks
• Sequence Patterns: Identify common task sequences
• Time Patterns: Detect time-based patterns
• Context Patterns: Learn contextual triggers

2. Workflow Generation

• Auto-Create: Generate workflow from patterns
• Step Optimization: Optimize workflow steps
• Error Handling: Add robust error handling
• Parallelization: Identify parallelizable steps

3. Automation

• Scheduled Triggers: Time-based execution
• Event Triggers: Event-based execution
• Conditional Logic: Branching workflows
• Looping: Repeat workflows as needed

4. Learning

• Success Tracking: Monitor workflow success
• Auto-Improve: Refine based on results
• User Feedback: Incorporate user corrections
• Cross-User Learning: Share across users

Installation

pip install numpy pandas scikit-learn

Usage

Initialize Discoverer

from workflow_discoverer import WorkflowDiscoverer

discoverer = WorkflowDiscoverer(
    user_id="user123",
    min_occurrences=3
)

Record Task History

# Record task execution
discoverer.record_task(
    task="send daily report",
    steps=["fetch_data", "generate_chart", "send_email"],
    context={"time": "morning", "recipients": ["team"]},
    result="success"
)

# Record multiple similar tasks
for i in range(5):
    discoverer.record_task(
        task="weekly summary",
        steps=["collect_stats", "format_report", "post_to_slack"],
        context={"day": "friday"},
        result="success"
    )

Discover Workflows

# Discover potential workflows
workflows = discoverer.discover_workflows()

for wf in workflows:
    print(f"Workflow: {wf['name']}")
    print(f"Pattern: {wf['pattern']}")
    print(f"Confidence: {wf['confidence']:.0%}")
    print(f"Time saved: {wf['time_saved_minutes']} min")

Create Automation

# Create automated workflow
automation = discoverer.create_automation(
    workflow_id="weekly_summary",
    trigger={"type": "schedule", "time": "friday 09:00"},
    enabled=True
)

print(f"Automation created: {automation['id']}")

API Reference

Recording

Method	Description
record_task(...)	Record task execution
record_sequence(...)	Record task sequence
import_history(...)	Import from external source

Discovery

Method	Description
discover_workflows()	Find workflow patterns
analyze_sequences()	Analyze task sequences
detect_triggers()	Detect trigger patterns

Automation

Method	Description
create_automation(...)	Create automation
enable_automation(id)	Enable workflow
disable_automation(id)	Disable workflow
run_automation(id)	Run manually

Learning

Method	Description
track_results()	Track automation results
improve_workflow()	Improve based on results
merge_patterns()	Merge similar patterns

Workflow Templates

Common Discovered Workflows

# Data Analysis Workflow
{
    "name": "daily_data_review",
    "steps": [
        "fetch_yesterday_data",
        "run_analysis",
        "generate_report",
        "send_to_stakeholders"
    ],
    "trigger": "schedule: 09:00 daily",
    "time_saved": 30  # minutes
}

# Content Publishing Workflow
{
    "name": "cross_platform_post",
    "steps": [
        "create_content",
        "adapt_for_twitter",
        "adapt_for_linkedin",
        "schedule_posts"
    ],
    "trigger": "manual",
    "time_saved": 45
}

# Research Workflow
{
    "name": "topic_research",
    "steps": [
        "search_web",
        "filter_sources",
        "extract_key_info",
        "generate_summary"
    ],
    "trigger": "event: new_topic",
    "time_saved": 60
}

Pattern Detection

Task Similarity

Task: "send report to john"
Task: "send report to team"  
Similarity: 0.85
→ Potential workflow: "send_report"

Sequence Patterns

[A, B, C] → D
[A, B, C] → D
[A, B, C] → D
Pattern: Auto-create [A,B,C] → D

Time Patterns

Task: "morning standup" at 09:00 daily
Task: "morning standup" at 09:05 daily
→ Suggest: Scheduled automation at 09:00

Example: Full Workflow

# 1. Record user's recurring tasks
discoverer = WorkflowDiscoverer("user123")

# Over time, user does similar tasks
discoverer.record_task(
    task="analyze stock 600519",
    steps=["fetch_data", "compute_indicators", "generate_signal"],
    context={"stock": "600519", "type": "analysis"}
)

discoverer.record_task(
    task="analyze stock 000858",
    steps=["fetch_data", "compute_indicators", "generate_signal"],
    context={"stock": "000858", "type": "analysis"}
)

# 2. Discover patterns
workflows = discoverer.discover_workflows()

# 3. Create automation
if workflows:
    wf = workflows[0]
    
    automation = discoverer.create_automation(
        workflow_id=wf['id'],
        trigger={"type": "schedule", "cron": "0 9 * * 1-5"},
        params={"stocks": ["600519", "000858", "600036"]}
    )
    
    print(f"Created: {automation['name']}")

Use Cases

• Report Generation: Auto-create scheduled reports
• Data Processing: Pipeline repetitive analysis
• Communication: Automate routine messages
• Research: Streamline information gathering
• Trading: Systematic trading routines

Metrics

Discovered Patterns

• Task frequency
• Sequence consistency
• Time regularity
• Context similarity

Workflow Value

• Time saved per execution
• Error reduction
• Consistency improvement

Integration

With OpenClaw

# Auto-discover from conversation
@hookimpl
def after_message(message, response):
    discoverer.record_task(
        task=extract_intent(message),
        steps=extract_tools_used(response),
        result="success"
    )

With Skills

# Learn from skill usage
for skill in used_skills:
    discoverer.record_task(
        task=skill.name,
        steps=skill.execution_steps,
        context=skill.context,
        result=skill.result
    )

Best Practices

1. More Data = Better Patterns: Record more tasks for accuracy
2. Verify Before Automating: Review discovered workflows
3. Start Simple: Begin with 2-3 step workflows
4. Monitor Results: Track automation success
5. Iterate: Continuously improve workflows

Future Capabilities

• Natural language workflow creation
• Cross-user pattern sharing
• AI-generated workflow optimization
• Self-healing workflows