English  ·  简体中文  ·  Website

TaskMeld

Agent Pipeline Orchestration Platform

Compose OpenClaw agents into executable pipelines — define, run, observe, and iterate with Wevra Agent.

[!TIP] The Stack:

• OpenClaw — Agent execution runtime (pipeline nodes)
• TaskMeld — Pipeline orchestration engine (DAG, scheduling, artifacts)
• Wevra — Built-in Agent (operates pipelines via natural language)

🏗️ Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                     User / Wevra Agent                    │
│         (Natural language pipeline management)               │
└───────────────────────────┬─────────────────────────────────┘
                            │
┌───────────────────────────▼─────────────────────────────────┐
│                    TaskMeld (This Repo)                      │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Pipeline Engine (DAG · Scheduler · State Machine)    │   │
│  │  • Node dependency graphs                            │   │
│  │  • Parallel groups & routing branches                │   │
│  │  • Per-node retry & artifact tracking                │   │
│  └──────────────────────────────────────────────────────┘   │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Wevra Agent (40 tools · ReAct loop · Memory)      │   │
│  │  • Pipeline CRUD & monitoring                        │   │
│  │  • Agent lifecycle management                        │   │
│  │  • Failure diagnosis & optimization                  │   │
│  └──────────────────────────────────────────────────────┘   │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ OpenClaw Management (Detect · Install · Gateway)    │   │
│  │  • Auto-detect local OpenClaw installation          │   │
│  │  • One-click install (npm install -g openclaw)      │   │
│  │  • Gateway start/stop/status                        │   │
│  └──────────────────────────────────────────────────────┘   │
└───────────────────────────┬─────────────────────────────────┘
                            │ Gateway RPC
┌───────────────────────────▼─────────────────────────────────┐
│                    OpenClaw Gateway                          │
│  (Agent registry · Session management · Event relay)         │
└───────────────────────────┬─────────────────────────────────┘
                            │
┌───────────────────────────▼─────────────────────────────────┐
│                  OpenClaw Agent Runtime                      │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐      │
│  │  Node 1  │ │  Node 2  │ │  Node 3  │ │  Node 4  │      │
│  │ (Agent A)│ │ (Agent B)│ │ (Agent C)│ │ (Agent D)│      │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘      │
│  (Each pipeline node binds an OpenClaw agent)                │
└─────────────────────────────────────────────────────────────┘

How it works:

1. TaskMeld orchestrates pipelines as DAGs with dependencies, routing, and retries
2. Each pipeline node binds an OpenClaw agent that executes the actual work
3. Wevra Agent operates the entire stack through natural language
4. OpenClaw Management module handles auto-detection, one-click install, and Gateway lifecycle

🚀 Why TaskMeld?

The Problem

Managing complex agent pipelines requires constant manual intervention: creating configurations, monitoring runs, diagnosing failures, and iterating on designs. This is time-consuming, error-prone, and doesn't scale.

The Solution: Three-Layer Stack

Why Not Just OpenClaw?

OpenClaw supports direct agent-to-agent communication (via OpenClaw config files), so why add TaskMeld?

OpenClaw alone:

• Point-to-point calls — agents communicate directly, no orchestration
• Config-based wiring — agent-to-agent calls require manual OpenClaw config files, inflexible
• Manual coordination — you define the flow in code each time
• No retry or recovery — if something fails, you start over

With TaskMeld:

• DAG orchestration — Define complex dependencies, parallel groups, and routing branches declaratively
• State persistence — Every execution is recorded; retry failed nodes, resume interrupted runs
• Artifact tracking — Complete lineage of data flowing between agents
• Scheduled execution — Cron-based or event-driven triggers
• Wevra Agent — Manage the entire stack through natural language

In short: OpenClaw executes agents; TaskMeld orchestrates them.

Result: Transform from you operate the pipelines to Wevra operates the pipelines, and you direct.

✨ Key Features

🔧 Pipeline Engine (Core)

• DAG Orchestration — Node dependency graphs, parallel groups, routing branches
• Per-Node Retry — Automatic retry with configurable policies
• State Persistence — All state stored as JSON files, zero external database
• Artifact Tracking — Complete lineage of pipeline outputs
• OpenClaw Integration — Seamless agent execution via Gateway

🤖 Wevra Agent

• 40 Built-in Tools — Pipeline CRUD, Agent management via Gateway, System monitoring, Memory, Skills
• Natural Language Interface — "List all pipelines", "Run the data processing pipeline", "What failed in the last run?"
• Multi-Provider LLM Support — DeepSeek, OpenAI, and custom providers
• ReAct Loop — Standard Reasoning + Acting pattern for intelligent task execution
• Real-time Streaming — WebSocket-based streaming of thinking process and execution results
• Permission Control — Three modes: Plan (read-only), Normal (confirm writes), Auto (full access)
• Cross-Session Memory — Remembers preferences, patterns, and solutions

🔌 OpenClaw Integration

• Agent Registry — List, create, update, delete agents via Gateway
• Session Management — Send messages, track conversations, view history
• Event Relay — Real-time events from agent execution
• Delegated Execution — Pipeline nodes delegate work to OpenClaw agents
• Auto-Detection & Installation — init command auto-detects local OpenClaw, one-click install, and generates Gateway config

🖥️ Multi-Interface Access

• Web Console — React 19 dashboard with DAG visualization, WevraChatPanel, and monitoring
• CLI Tool — Full lifecycle management for automation and scripting
• WebSocket API — 19 methods for real-time control and observability

🎯 Use Cases

1. Intelligent Pipeline Management

You: Create a pipeline that processes daily sales data using OpenClaw agents
Wevra: [Creates pipeline with 4 nodes, each binding an OpenClaw agent]
       Pipeline created. Each node will execute via OpenClaw agents.
       Would you like me to schedule it to run daily at 9 AM?

2. Agent Lifecycle Management

You: List all OpenClaw agents and their status
Wevra: [Calls agent_list via Gateway]
       You have 5 agents: DataCollector, Analyzer, Reporter, Cleaner, Notifier
       
You: Create a new OpenClaw agent for customer segmentation
Wevra: [Creates agent via Gateway]
       Agent "Segmenter" created and ready for pipeline assignment.

3. Autonomous Failure Recovery

You: The sales pipeline failed last night. What happened?
Wevra: [Analyzes pipeline status and OpenClaw agent logs]
       Root cause: OpenClaw agent "DataCollector" timed out on Node 2.
       Impact: 3 downstream nodes skipped.
       Action: I've increased the timeout and added a fallback agent.

4. Cross-System Orchestration

You: Create a pipeline that chains 3 OpenClaw agents: collect → analyze → report
Wevra: [Creates DAG with dependencies]
       Pipeline configured. Agent execution order:
       1. DataCollector (OpenClaw) → artifacts
       2. Analyzer (OpenClaw) → consumes artifacts → produces analysis
       3. Reporter (OpenClaw) → consumes analysis → generates report

📦 Prerequisites

[!IMPORTANT] Pipeline execution requires OpenClaw. TaskMeld's init command can auto-detect a local installation or install OpenClaw with one command and generate Gateway configuration. You can also install OpenClaw manually and connect via init, or configure a remote Gateway address.

🔧 Install

1. Install TaskMeld

npm install -g taskmeld

2. Initialize (First-time Setup)

taskmeld init

The init command guides you through:

• Language selection (English / Chinese)
• Auto-detection of local OpenClaw installation
• OpenClaw found → auto-connect to running Gateway
• OpenClaw not found → three options:
  • Auto-install — install OpenClaw via npm and generate config
  • Remote Gateway — configure remote OpenClaw Gateway URL and Token
  • Manual install — install OpenClaw yourself and re-run init
• Optional model configuration (after auto-install)

Configuration is saved to ~/.taskmeld/config.json.

Non-interactive Mode

# Auto-install OpenClaw and configure
taskmeld init --auto-install

# Configure remote Gateway
taskmeld init --remote ws://your-gateway:18789 --token your-token

# Direct URL and Token (for CI/CD)
taskmeld init --url ws://127.0.0.1:18789 --token your-token

🚀 Quick Start

Standard Flow

# Initialize — auto-detect OpenClaw, install if missing, configure Gateway
taskmeld init

# Start the backend daemon (auto-starts local OpenClaw Gateway)
taskmeld server start

# Open browser to Web Console
# Visit http://127.0.0.1:54320 and use the Wevra chat panel to manage pipelines

Unattended Flow (CI/CD, automation)

# One-step: install + configure + start
taskmeld init --auto-install && taskmeld server start

Command Reference

Init

Server

Pipeline & Management

Full command reference: taskmeld --help or CLI docs.

💬 Chat with Wevra

After starting the server, access the Web Console at http://127.0.0.1:54320 and use the Wevra chat panel:

You: What OpenClaw agents do I have?
Wevra: You have 5 agents registered: DataCollector, Analyzer, Reporter, Cleaner, Notifier

You: Create a pipeline using DataCollector and Analyzer
Wevra: [Creates pipeline with 2 nodes binding these OpenClaw agents]
       Pipeline created. Node 1 uses DataCollector, Node 2 uses Analyzer.

You: Run the pipeline and monitor execution
Wevra: Pipeline started. Monitoring OpenClaw agent execution...
       Node 1 (DataCollector): ✅ Complete
       Node 2 (Analyzer): ✅ Complete
       All agents completed successfully.

🏗️ Directory Structure

🛠️ Development

npm install          # Install dependencies
npm run build        # Build
npm run typecheck    # Type check only
npm run lint         # Lint
npm run format       # Format code
npm run format:check # Check code format
npm test             # Run tests
npm run dev          # Start backend dev server (tsx hot-reload)
npm run dev:cli      # Start CLI dev mode
npm run dev:web      # Start frontend dev server (Vite HMR)

🌟 Roadmap

Current

• ✅ DAG pipeline engine with OpenClaw agent execution
• ✅ Wevra Agent with 40 tools
• ✅ Agent lifecycle management via OpenClaw Gateway
• ✅ OpenClaw auto-detection, installation, and Gateway management
• ✅ CLI, WebSocket API, and Web console
• ✅ Server bound to localhost (security hardening)

Upcoming

• 🔶 Pipeline-scoped conversations
• 🔶 Cross-pipeline access control
• 🔶 Enhanced memory system

Future

• 📋 Multi-agent collaboration patterns
• 📋 Advanced scheduling (cron, event-driven)
• 📋 Plugin ecosystem

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Areas where help is needed:

• Testing on macOS and Linux
• Additional LLM provider integrations
• OpenClaw agent tool implementations
• Documentation improvements

📄 License

MIT — see LICENSE

OpenClaw + TaskMeld + Wevra = Automated Agent Pipelines
_{Execute · Orchestrate · Automate}