What makes Agent Workflow notable?

2.1K downloads. Trust evidence available

How should Agent Workflow 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

Agent Workflow

A structured workflow plugin for OpenClaw agents. Guides work through brainstorm → plan → execute → verify → deliver with persistent state and multi-project... Skill: Agent Workflow Owner: kangyishuai Summary: A structured workflow plugin for OpenClaw agents. Guides work through brainstorm → plan → execute → verify → deliver with persistent state and multi-project... Tags: latest:1.1.0 Version history: v1.1.0 | 2026-06-04T03:33:02.695Z | user Security audit fixes: narrowed trigger scopes for all skills (SQP-1), removed forced 1% activation threshold, added explicit user con

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

2.1k

Updated

Oct 9, 2026

Version

1.1.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 2.1K downloads reported by the source. Last updated 10/9/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 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 2.1K downloadsadoption · observed Oct 9, 2026
Latest release: 1.1.0release · observed Jun 4, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17fmah22ce1z7x3h81hqbdp9n83kkdx:agent-workflow

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-kangyishuai-agent-workflow/snapshot"

Documentation

CLAWHUB

120,102 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: agent-workflow
description: "A structured workflow plugin for OpenClaw agents. Guides work through brainstorm → plan → execute → verify → deliver with persistent state and multi-project support. Trigger ONLY when the user explicitly requests a structured workflow (e.g. 'start a workflow', 'use agent-workflow', 'plan this project'). Do NOT trigger for: simple questions, one-off tasks, quick edits, routine conversations, or any task where the user has not requested workflow management."
---

# Agent Workflow

A structured workflow engine for OpenClaw agents. Migrated and generalized from the [superpowers](https://github.com/anthropics/claude-code-superpowers) workflow system into a code-agnostic, general-purpose workflow plugin.

## What it does

Provides a persistent state machine that guides your agent through a complete work lifecycle:

```
brainstorming → writing-plans → [execute] → verification → finishing-work
                                     ↓
                          subagent-driven-execution
                               OR
                          executing-plans
```

With support for:
- **Persistent state** — workflow survives session restarts
- **Multi-project** — run multiple workflows concurrently
- **Branching** — choose execution strategy at branch points
- **Context-plugins** — fork into review/parallel-agents without leaving main flow
- **Soft-guard goto** — jump to any step with warnings about skipped prerequisites
- **11 bundled Skills** — covering the full workflow lifecycle

## Installation

This is a **Plugin**, not a plain Skill. Install via:

```bash
openclaw plugins install clawhub:agent-workflow
openclaw gateway restart
```

Then enable in your `~/.openclaw/openclaw.json`:

```json
{
  "plugins": {
    "allow": ["agent-workflow"]
  },
  "tools": {
    "allow": ["agent_workflow"]
  }
}
```

## Usage

In your agent (via Feishu, Discord, or any channel):

```
Start a new workflow for my Q2 planning project
```

The agent will call `agent_workflow` with `action: "start"` and guide you through the workflow.

## Tool: `agent_workflow`

| Action | Description |
|--------|-------------|
| `start` | Begin a new workflow |
| `status` | View current state (all active workflows if no ID given) |
| `next` | Advance to the next step |
| `goto` | Jump to any node (soft-guard warns about skipped steps) |
| `complete` | Mark current node done |
| `fork` | Activate a context-plugin without leaving main flow |
| `join` | Complete a fork and return |
| `getSkill` | Load full SKILL.md for the current node |
| `list` | List all workflows |
| `abandon` | Abandon a workflow |

## Bundled Skills

- `brainstorming` — Turn ideas into specs
- `writing-plans` — Break specs into tasks
- `executing-plans` — Sequential execution
- `subagent-driven-execution` — Parallel subagent execution
- `verification-before-completion` — Evidence before claims
- `finishing-work` — Delivery options
- `dispatching-parallel-agents` — Fork independent ta

skills/brainstorming/SKILL.md

---
name: brainstorming
description: "Use when the user explicitly requests design exploration, brainstorming, or says they want to discuss approaches before building. Explores user intent, requirements, and design through collaborative dialogue. Trigger ONLY when the user asks to brainstorm, explore options, or design a solution. Do NOT trigger for: simple questions, direct instructions, quick edits, routine tasks, feedback responses, mid-task interactions, or when the user wants immediate action."
---

# Brainstorming Ideas Into Designs

Help turn ideas into fully formed designs and specs through natural collaborative dialogue.

Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design and get user approval.

<HARD-GATE>
Do NOT invoke any execution skill, take any implementation action, or start producing deliverables until you have presented a design and the user has approved it. This applies to EVERY task regardless of perceived simplicity.
</HARD-GATE>

## Anti-Pattern: "This Is Too Simple To Need A Design"

Every task goes through this process. A short document, a minor change, a config tweak — all of them. "Simple" tasks are where unexamined assumptions cause the most wasted work. The design can be short (a few sentences for truly simple tasks), but you MUST present it and get approval.

## Checklist

You MUST create a task for each of these items and complete them in order:

1. **Explore project context** — check existing files, docs, prior work
2. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria
3. **Propose 2-3 approaches** — with trade-offs and your recommendation
4. **Present design** — in sections scaled to their complexity, get user approval after each section
5. **Confirm next step with user** — ask the user if they want a written spec saved to disk, or if the conversation summary is sufficient
6. **Write design doc (if requested)** — only if user confirms, save to `docs/specs/YYYY-MM-DD-<topic>-design.md`
7. **Spec self-review (if written)** — quick inline check for placeholders, contradictions, ambiguity, scope (see below)
8. **User reviews written spec** — ask user to review the spec file before proceeding
9. **Ask user about next step** — ask if user wants to proceed to execution planning; do NOT automatically invoke other skills

## Process Flow

```dot
digraph brainstorming {
    "Explore project context" [shape=box];
    "Ask clarifying questions" [shape=box];
    "Propose 2-3 approaches" [shape=box];
    "Present design sections" [shape=box];
    "User approves design?" [shape=diamond];
    "User wants written spec?" [shape=diamond];
    "Write design doc" [shape=box];
    "Spec self-review\n(fix inline)" [shape=box];
    "User reviews spec?" [shape=diamond];
    "Ask user about next step" [shape=doublecircle];

    "Explore project context" -> "Ask clarifying questions";

skills/dispatching-parallel-agents/SKILL.md

---
name: dispatching-parallel-agents
description: "Use when facing 2 or more independent tasks that can be worked on without shared state or sequential dependencies. Trigger when multiple independent problems or tasks need to be investigated or executed simultaneously. Do not trigger when tasks share state, when one depends on another's output, or when you need full context to understand the overall situation first."
---

# Dispatching Parallel Agents

## Overview

You delegate tasks to specialized agents with isolated context. By precisely crafting their instructions and context, you ensure they stay focused and succeed at their task. They should never inherit your session's context or history — you construct exactly what they need. This also preserves your own context for coordination work.

When you have multiple unrelated tasks (different topics, different areas, different problems), working on them sequentially wastes time. Each task is independent and can happen in parallel.

**Core principle:** Dispatch one agent per independent problem domain. Let them work concurrently.

## When to Use

```dot
digraph when_to_use {
    "Multiple tasks?" [shape=diamond];
    "Are they independent?" [shape=diamond];
    "Single agent handles all" [shape=box];
    "One agent per task domain" [shape=box];
    "Can they work in parallel?" [shape=diamond];
    "Sequential agents" [shape=box];
    "Parallel dispatch" [shape=box];

    "Multiple tasks?" -> "Are they independent?" [label="yes"];
    "Are they independent?" -> "Single agent handles all" [label="no - related"];
    "Are they independent?" -> "Can they work in parallel?" [label="yes"];
    "Can they work in parallel?" -> "Parallel dispatch" [label="yes"];
    "Can they work in parallel?" -> "Sequential agents" [label="no - shared state"];
}
```

**Use when:**
- 3+ independent tasks with different domains
- Multiple areas broken independently
- Each task can be understood without context from others
- No shared state between tasks

**Don't use when:**
- Tasks are related (completing one might affect others)
- Need to understand full project state first
- Agents would interfere with each other (editing same files, using same resources)

## The Pattern

### 1. Identify Independent Domains

Group tasks by what's involved:
- Task A: Research topic X
- Task B: Draft section Y
- Task C: Review document Z

Each domain is independent — researching X doesn't affect drafting Y.

### 2. Create Focused Agent Tasks

Each agent gets:
- **Specific scope:** One task or domain
- **Clear goal:** What to produce
- **Constraints:** What NOT to do
- **Expected output:** Summary of what was found/produced

### 3. Dispatch in Parallel

```
Agent 1 → Task A: Research topic X
Agent 2 → Task B: Draft section Y
Agent 3 → Task C: Review document Z
// All three run concurrently
```

### 4. Review and Integrate

When agents return:
- Read each summary
- Verify outputs don't conflict
- Integrate all results
- Verify the combined

skills/executing-plans/SKILL.md

---
name: executing-plans
description: "Use when you have a written plan to execute, working through tasks sequentially with review checkpoints. Trigger when a plan document exists and the user wants to execute it in the current session. Do not trigger without an existing plan document. If subagents are available, prefer agent-workflow:subagent-driven-execution instead."
---

# Executing Plans

## Overview

Load plan, review critically, execute all tasks, report when complete.

**Announce at start:** "I'm using the executing-plans skill to implement this plan."

**Note:** This skill works much better with subagent support. If subagents are available, use `agent-workflow:subagent-driven-execution` instead — it provides higher quality through fresh context per task and two-stage review.

## The Process

### Step 1: Load and Review Plan

1. Read plan file
2. Review critically — identify any questions or concerns about the plan
3. If concerns: Raise them with the user before starting
4. If no concerns: Create task list and proceed

### Step 2: Execute Tasks

For each task:
1. Mark as in_progress
2. Follow each step exactly (plan has bite-sized steps)
3. Run verifications as specified
4. Mark as completed

### Step 3: Complete Work

After all tasks complete and verified:
- Announce: "I'm using the finishing-work skill to complete this work."
- **REQUIRED SUB-SKILL:** Use `agent-workflow:finishing-work`
- Follow that skill to verify outputs, present options, execute choice

## When to Stop and Ask for Help

**STOP executing immediately when:**
- Hit a blocker (missing input, verification fails, instruction unclear)
- Plan has critical gaps preventing starting
- You don't understand an instruction
- Verification fails repeatedly

**Ask for clarification rather than guessing.**

## When to Revisit Earlier Steps

**Return to Review (Step 1) when:**
- User updates the plan based on your feedback
- Fundamental approach needs rethinking

**Don't force through blockers** — stop and ask.

## Remember
- Review plan critically first
- Follow plan steps exactly
- Don't skip verifications
- Reference skills when plan says to
- Stop when blocked, don't guess

## Integration

**Required workflow skills:**
- `agent-workflow:writing-plans` — Creates the plan this skill executes
- `agent-workflow:finishing-work` — Complete work after all tasks are done

skills/finishing-work/SKILL.md

---
name: finishing-work
description: "Use when a task or project phase is complete and you need to decide how to deliver or integrate the work. Trigger after all tasks are done and verified. Do not trigger before verification is complete or while tasks are still in progress."
---

# Finishing Work

## Safety Notice

**This skill includes options that may permanently delete drafts, temporary files, or working copies.** All destructive actions (Option 4: Discard, and cleanup steps) require explicit user confirmation before execution. Only clearly identified temporary files created during this workflow will be removed — user-created artifacts are never deleted without specific confirmation.

## Overview

Guide completion of a work phase by presenting clear options and handling the chosen delivery workflow.

**Core principle:** Verify work → Present options → Execute choice → Clean up.

**Announce at start:** "I'm using the finishing-work skill to complete this work."

## The Process

### Step 1: Verify Work

**Before presenting options, verify the work is complete:**

Check each of the following:
- All planned tasks are done
- All acceptance criteria are met
- No known issues remain unaddressed

**If verification fails:**
```
Work incomplete or issues remain:

[Show what's missing or broken]

Cannot proceed with delivery until work is verified complete.
```

Stop. Don't proceed to Step 2.

**If verification passes:** Continue to Step 2.

### Step 2: Confirm Delivery Target

Ask or confirm: "Where does this work go? Who receives it?"

Examples:
- Integrate into main project
- Submit to stakeholder for review
- Keep as draft for later
- Discard

### Step 3: Present Options

Present exactly these 4 options:

```
Work complete. What would you like to do?

1. Integrate into main project directly
2. Submit for review / deliver to stakeholder
3. Keep as-is (I'll handle it later)
4. Discard this work

Which option?
```

**Don't add explanation** — keep options concise.

### Step 4: Execute Choice

#### Option 1: Integrate Directly

1. Merge or apply the work into the main project
2. Verify the integrated result still meets requirements
3. Clean up any working drafts or temporary files
4. Confirm integration complete

#### Option 2: Submit for Review / Deliver

1. Package or prepare the output for delivery
2. Send to stakeholder or submit for review
3. Note any context the reviewer needs
4. Keep working copy until review is complete

Then: Clean up workspace (Step 5)

#### Option 3: Keep As-Is

Report: "Keeping work in progress at [location]. No delivery action taken."

**Don't clean up.**

#### Option 4: Discard

**Confirm first:**
```
This will permanently delete:
- [Description of what will be deleted]
- [Any associated drafts or working files]

Type 'discard' to confirm.
```

Wait for exact confirmation.

If confirmed: Remove the work and working files.

Then: Clean up workspace (Step 5)

### Step 5: Clean Up Workspace

**For Options 1, 2, 4:**

Before

Github ReposUpdated 8h 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.