# Send Clawflow to your agent
Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually.
## Fast path
- Download the package from Yavira.
- Extract it into a folder your agent can access.
- Paste one of the prompts below and point your agent at the extracted folder.
## Suggested prompts
### New install

```text
I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Tell me what you changed and call out any manual steps you could not complete.
```
### Upgrade existing

```text
I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Summarize what changed and any follow-up checks I should run.
```
## Machine-readable fields
```json
{
  "schemaVersion": "1.0",
  "item": {
    "slug": "clawflow",
    "name": "Clawflow",
    "source": "tencent",
    "type": "skill",
    "category": "通讯协作",
    "sourceUrl": "https://clawhub.ai/srikanth235/clawflow",
    "canonicalUrl": "https://clawhub.ai/srikanth235/clawflow",
    "targetPlatform": "OpenClaw"
  },
  "install": {
    "downloadUrl": "/downloads/clawflow",
    "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=clawflow",
    "sourcePlatform": "tencent",
    "targetPlatform": "OpenClaw",
    "packageFormat": "ZIP package",
    "primaryDoc": "SKILL.md",
    "includedAssets": [
      "schemas.md",
      "message.py",
      "agent-loop.md",
      "SKILL.md",
      "init.py",
      "coordinating.md"
    ],
    "downloadMode": "redirect",
    "sourceHealth": {
      "source": "tencent",
      "slug": "clawflow",
      "status": "healthy",
      "reason": "direct_download_ok",
      "recommendedAction": "download",
      "checkedAt": "2026-04-29T13:48:46.674Z",
      "expiresAt": "2026-05-06T13:48:46.674Z",
      "httpStatus": 200,
      "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=clawflow",
      "contentType": "application/zip",
      "probeMethod": "head",
      "details": {
        "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=clawflow",
        "contentDisposition": "attachment; filename=\"clawflow-1.0.0.zip\"",
        "redirectLocation": null,
        "bodySnippet": null,
        "slug": "clawflow"
      },
      "scope": "item",
      "summary": "Item download looks usable.",
      "detail": "Yavira can redirect you to the upstream package for this item.",
      "primaryActionLabel": "Download for OpenClaw",
      "primaryActionHref": "/downloads/clawflow"
    },
    "validation": {
      "installChecklist": [
        "Use the Yavira download entry.",
        "Review SKILL.md after the package is downloaded.",
        "Confirm the extracted package contains the expected setup assets."
      ],
      "postInstallChecks": [
        "Confirm the extracted package includes the expected docs or setup files.",
        "Validate the skill or prompts are available in your target agent workspace.",
        "Capture any manual follow-up steps the agent could not complete."
      ]
    }
  },
  "links": {
    "detailUrl": "https://openagent3.xyz/skills/clawflow",
    "downloadUrl": "https://openagent3.xyz/downloads/clawflow",
    "agentUrl": "https://openagent3.xyz/skills/clawflow/agent",
    "manifestUrl": "https://openagent3.xyz/skills/clawflow/agent.json",
    "briefUrl": "https://openagent3.xyz/skills/clawflow/agent.md"
  }
}
```
## Documentation

### Clawflow

A protocol for OpenClaw agents collaborating through messages and recursive task DAGs.

Mental model: Think of a consulting firm. Anyone can receive a project. If they can
do it alone, they do. If it's too big, they break it into pieces, hand each piece to a
colleague, collect the results, and synthesise. Those colleagues might do the same.
There are no fixed "managers" and "workers." Every agent speaks the same protocol.

### When to Read References

Message formats, task file structure, status codes → references/schemas.md
The decision loop every agent runs → references/agent-loop.md
DAG decomposition, context passing, synthesis → references/coordinating.md

### Core Principles

One protocol, fluid roles — every agent is structurally identical. Any agent can
execute work directly or decompose and delegate. The role emerges from the task.
OpenClaw is the backbone — agent identity comes from openclaw.json config,
peer discovery from openclaw agents list, and message transport from
openclaw agent --agent <id> --message "...". No custom identity or peer files.
Recursive DAGs — an agent that delegates becomes a coordinator for that sub-DAG.
Its parent doesn't know or care. DAGs nest naturally.
Workspace = working memory — each agent's OpenClaw workspace is its private
scratchpad. Task state lives in workspace files. No agent reads another's workspace.

### How It Works

Agent A receives a task
  → Can I do this alone?
     YES → Execute, reply with results
     NO  → Decompose into sub-DAG
           → Dispatch subtasks to Agents B, C via openclaw agent
           → Agent B receives its subtask
              → Can I do this alone?
                 YES → Execute, reply to A
                 NO  → Decompose further, dispatch to D, E...
           → Agent C executes, replies to A
           → A collects all replies, synthesises, replies to *its* parent

Every level looks the same. An agent at any depth follows the same loop.

### Agent Identity

Comes from the OpenClaw configuration. Do NOT create custom identity files.

Config source: openclaw.json → agents.list[].id, agents.list[].identity
Workspace source: IDENTITY.md in the agent's workspace root
Read with: openclaw agents list or from injected bootstrap context

Each agent already knows who it is — its id, name, emoji, and theme are
injected into the session context on every turn via the workspace bootstrap files
(IDENTITY.md, SOUL.md, AGENTS.md).

### Peer Discovery

Discover available agents from OpenClaw configuration. Do NOT maintain a separate
peers file.

# List all configured agents
openclaw agents list

# The config defines them:
# agents.list[].id        → agent identifier (used in --agent flag)
# agents.list[].workspace → their workspace path
# agents.list[].model     → their model

An agent's subagents.allowAgents config controls which agents it can delegate to.
["*"] means it can reach any agent.

### Sending Tasks to Peers

Use the OpenClaw CLI to send a task message to another agent:

# Send a task to a specific agent
openclaw agent --agent data-extractor --message "Extract Q3 sales from sales.csv"

# The receiving agent gets this in its session, processes it,
# and the response comes back through the same mechanism

For structured task dispatch with metadata, write the task message to a file and
reference it:

openclaw agent --agent data-extractor \\
  --message "$(cat workspace/tasks/task-abc/dispatch-st-extract.md)"

### Workspace Layout for Clawflow

Each agent uses its existing OpenClaw workspace. Clawflow adds a tasks/ directory:

<agent-workspace>/                   ← OpenClaw workspace root
  IDENTITY.md                        ← Agent identity (OpenClaw-managed)
  AGENTS.md                          ← Operating instructions (OpenClaw-managed)
  SOUL.md                            ← Persona (OpenClaw-managed)
  mailbox/                           ← Agent-level message log (all tasks)
    inbox/                           ← Incoming messages before processing
    outbox/                          ← Outgoing messages (dispatches + replies sent)
    archive/                         ← Processed messages (durable audit trail)
  tasks/                             ← Clawflow working directory
    {task-id}/
      task.md                        ← DAG definition + progress + results
  skills/
    clawflow/                        ← This skill
      SKILL.md
      ...

Clawflow adds two top-level directories to the workspace:

mailbox/ — agent-level message log, independent of any task. Every message
the agent sends or receives is logged here. inbox/ holds unprocessed arrivals,
outbox/ logs what was sent, archive/ holds processed messages. This is the
durable audit trail — OpenClaw session history compacts over time, the mailbox doesn't.
tasks/ — one subdirectory per task with a task.md tracking DAG state, subtask
results, and the final synthesised output.

### The Agent Loop

When an agent receives a task (via openclaw agent --message):

1. Parse the message
2. Is it a TASK from a parent?
   → Create task.md in workspace/tasks/{task-id}/
   → DECIDE: execute directly or decompose?
     → Direct: do the work, reply with results
     → Decompose: build sub-DAG in task.md, dispatch subtasks via openclaw agent
3. Is it a REPLY from a peer I delegated to?
   → Update sub-DAG in task.md (mark subtask done, store results)
   → Dispatch any newly unblocked subtasks
   → If all subtasks done → synthesise results, reply to parent

Read references/agent-loop.md for the full decision logic and edge cases.

### Delegation Decision

When an agent receives a task, it decides: do it myself or delegate?

Execute directly when:

The task is within the agent's own capabilities
It's simple enough that decomposition adds overhead
No relevant peer agents are configured

Decompose and delegate when:

The task requires capabilities the agent doesn't have
The task has naturally parallel parts
The task is large enough that breaking it up reduces complexity

This is a judgment call. The protocol doesn't force it — the agent decides.

### DAG Dependency Resolution

When coordinating a sub-DAG, the agent tracks subtask status in task.md:

def get_ready_subtasks(dag):
    """Subtasks whose dependencies are all done and haven't been dispatched yet."""
    return [
        sid for sid, st in dag.subtasks.items()
        if st.status == 'pending'
        and all(dag.subtasks[dep].status == 'done' for dep in st.depends_on)
    ]

Called after every reply. Newly unblocked subtasks get dispatched immediately.

### Error Handling (V1)

Fail-fast. No retries, no partial recovery.

ScenarioBehaviourPeer fails a subtaskAgent marks its own task failed, replies with error to parentDuplicate messageIdempotency check — skip if task already in-progress or doneAgent crashesTask file in workspace preserves state; restart resumes from task.md

Errors propagate upward. Future versions will add retry and partial recovery.

### Implementation Checklist

Verify agent configuration — openclaw agents list to see available agents.
Check subagent permissions — ensure subagents.allowAgents includes target agents.
Implement the agent loop — follow references/agent-loop.md.
Use message templates — scripts/message.py generates structured task/reply messages.
Test a 2-level chain — agent A delegates to B, B executes and replies.
Test fan-out — agent A delegates to B and C in parallel.
Test recursion — agent A → B → C.

### Out of Scope (V1)

Large result attachments (Google Drive layer)
Task retry / partial DAG recovery
Agent health checks
Progress streaming
Cross-agent workspace access (by design, forever)
## Trust
- Source: tencent
- Verification: Indexed source record
- Publisher: srikanth235
- Version: 1.0.0
## Source health
- Status: healthy
- Item download looks usable.
- Yavira can redirect you to the upstream package for this item.
- Health scope: item
- Reason: direct_download_ok
- Checked at: 2026-04-29T13:48:46.674Z
- Expires at: 2026-05-06T13:48:46.674Z
- Recommended action: Download for OpenClaw
## Links
- [Detail page](https://openagent3.xyz/skills/clawflow)
- [Send to Agent page](https://openagent3.xyz/skills/clawflow/agent)
- [JSON manifest](https://openagent3.xyz/skills/clawflow/agent.json)
- [Markdown brief](https://openagent3.xyz/skills/clawflow/agent.md)
- [Download page](https://openagent3.xyz/downloads/clawflow)