agent-task-queue_skill

Overview

This skill builds and operates a multi-agent task queue for OpenClaw with rich orchestration features. It provides priority, delayed and dead-letter queues, scheduling with concurrency limits, retries, timeouts, dependency management, parallel execution, and execution tracing. The bundled TypeScript runtime and storage adapters let you run locally or across distributed workers.

How this skill works

The core pieces are TaskQueue (lifecycle, logs, metrics) and Scheduler (polling loop, concurrency, retry/timeout control). Tasks are enqueued with metadata (priority, runAt, dependencies, retryPolicy, timeoutMs) and become runnable only after dependency completion. Storage is pluggable: in-memory for tests, SQLite for single-node persistence, or Redis for distributed workers. The scheduler drives execution via tick() or start(), and handlers receive dependency results and an AbortSignal for cancellation.

When to use it

• You need coordinated work across multiple agents or worker processes.
• Tasks require dependency ordering or result propagation to downstream jobs.
• You must support retries, timeouts, and dead-letter handling for robustness.
• You want priority, delayed scheduling, and concurrency limits for throughput control.
• You need execution traces, logs, and metrics for observability and debugging.

Best practices

• Register typed handlers with scheduler.register(taskType, handler) and keep handlers idempotent.
• Use SQLite for single-host durability and Redis for horizontally scaled workers.
• Set sensible retryPolicy and timeoutMs values and let handlers respect context.signal for safe cancellation.
• Enqueue dependency tasks before dependents; validate DAGs to avoid cycles.
• Use queue.logs(), queue.metrics(), and queue.getSnapshot() to monitor health and tune concurrency.

Example use cases

• Orchestrating multi-step pipelines where each step depends on previous results.
• Running scheduled jobs with delayed start times and priority-based execution.
• Implementing a resilient worker pool with automatic retries and dead-letter handling.
• Distributing work across nodes using RedisStorage for large-scale processing.
• Testing complex task flows locally with InMemoryStorage and the bundled runtime.