home / skills / openclaw / skills / flow

flow skill

needs review

This skill orchestrates natural language requests into secure reusable FLOW workflows by composing and validating existing components.

npx playbooks add skill openclaw/skills --skill flow

Review the files below or copy the command above to add this skill to your agents.

Files (10)

SKILL.md

2.0 KB

---
name: flow
description: Intelligent skill orchestrator that compiles natural language requests into secure, reusable workflows
---

---
summary: Intelligent skill orchestrator that compiles natural language requests into secure, reusable workflows
tags:
  - automation
  - workflow
  - nlp
  - security
  - orchestration
  - skill-builder
  - clawdbot
  - mcp
---

# Flow

Intelligent Skill Orchestrator for Clawdbot/MCP - compose natural language requests into secure, reusable FLOW skills.

## Capabilities

- Parse natural language build requests
- Search skill registry for reusable components
- Security scan all skills before composition
- Compile multiple skills into unified FLOW
- Track skill usage for intelligent reuse
- Dependency resolution with topological sorting

## How It Works

1. **Natural Language Input**: Describe what you want to build
2. **Intent Parsing**: Extract capabilities, tags, and execution steps
3. **Registry Search**: Find existing skills that match requirements
4. **Security Scan**: Check all components for malicious patterns
5. **Composition**: Merge skills into single executable FLOW
6. **Registration**: Save new FLOW for future reuse

## Usage

### Interactive Mode
```
python flow.py
Flow> Build a web scraper that extracts prices and saves to CSV
```

### CLI Mode
```bash
python flow.py "Create an automation that monitors API endpoints"
```

### List Skills
```bash
python flow.py --list
```

## Security Features

- Code execution detection (eval, exec)
- Data exfiltration pattern matching
- Crypto mining indicator scanning
- System modification attempt detection
- AST-based code analysis
- Obfuscation detection

## Architecture

- `flow.py` - Main orchestrator
- `natural_language_parser.py` - NLP for user intent
- `skill_registry.py` - Reusable skill database
- `skill_scanner_integration.py` - Security scanning
- `skill_composer.py` - Compiles skills into FLOW

## Requirements

- Python 3.8+
- No external dependencies for core functionality

## Author

@bvinci1-design

Overview

This skill is an intelligent orchestrator that turns natural language requests into secure, reusable workflow skills called FLOWs. It finds and composes existing components, runs security scans, and registers compiled workflows for future reuse. The goal is fast, safe automation assembly from plain language.

How this skill works

User describes the desired automation in natural language. The parser extracts intents, tags, and execution steps, then searches a skill registry for matching components. Each candidate is security-scanned (AST and pattern checks) before the composer resolves dependencies and merges components into a single executable FLOW. The finished FLOW is registered for tracking and reuse.

When to use it

Rapidly prototype multi-step automations from plain language
Combine existing skills into a single, maintainable workflow
Enforce security checks before composing or executing third-party skills
Create reusable automation templates for teams or projects
Resolve complex skill dependencies automatically

Best practices

Write clear, stepwise natural language prompts specifying inputs, outputs, and constraints
Include tags or keywords to guide registry search (e.g., web-scraper, api-monitor)
Review security scan reports before granting execution privileges
Start with interactive mode for iterative refinement, then switch to CLI for automation
Version and tag produced FLOWs to enable reliable reuse and auditing

Example use cases

Compose a web scraper that extracts product prices, sanitizes data, and saves to CSV
Build an API monitoring workflow that alerts on latency and persists metrics
Assemble a data pipeline that fetches, transforms, and stores records using existing transform skills
Create a scheduled backup FLOW that discovers resources, verifies integrity, and archives outputs
Generate a custom skill from multiple small utilities, ensuring dependency order and security checks

FAQ

How does the skill ensure composed code is safe?

Every candidate skill is scanned with AST-based analysis and pattern matching for execution or exfiltration risks before composition; flagged components are excluded or require manual approval.

Can I reuse a FLOW created previously?

Yes. Compiled FLOWs are registered and tracked so they can be discovered and reused in future compositions.