ultrawork

Orchestrate parallel task execution across multiple agents with explicit model parameters.

1|Updated Mar 17, 2025
One-click install
npx skills add https://github.com/ozby/node-pubsub --skill ultrawork-ozby
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ultrawork
Source: https://github.com/ozby/node-pubsub/tree/main/.codex/skills/ultrawork
Command: npx skills add https://github.com/ozby/node-pubsub --skill ultrawork-ozby

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Ultrawork addresses the need to run multiple independent tasks in parallel across multiple agents, reducing total wall time and enabling scalable parallelism without persistence or state management concerns.

Core Features & Use Cases

  • Fire multiple independent tasks concurrently to maximize throughput
  • Route tasks to appropriate agent tiers and manage parallelism
  • Use with Ralph/autopilot stack to layer persistence and full lifecycle
  • Real-world use: run a batch of model inferences or data processing steps in parallel

Quick Start

Delegate multiple independent tasks to executor agents in parallel to start the ultrawork workflow.

Frequently Asked Questions about ultrawork

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I execute independent tasks concurrently across multiple agents?

To execute independent tasks concurrently, you can fire multiple tasks in parallel across executor agents. This maximizes throughput and reduces total wall time for workloads like batch model inferences or data processing.

What is parallel task orchestration and when do I need it?

Parallel task orchestration is the process of routing and executing independent tasks concurrently across multiple agents. You need it when running workloads like batch model inferences to reduce total wall time and maximize throughput.

Can I run long-running operations in the background while managing parallel workflows?

Yes, you can run long-running operations in the background. The execution lifecycle is managed by omx_state, allowing you to fire parallel tasks and maintain background operations without persistence concerns.

Does this parallel execution approach support explicit model parameter passing?

Yes, the workflow supports explicit model parameter passing. This allows you to route tasks to appropriate agent tiers and manage parallelism while retaining responsibility for the final results.

What are the limitations of running tasks concurrently without persistence?

Without persistence, you must handle final results manually as you retain responsibility for them. However, you can use it with the Ralph/autopilot stack to layer persistence and manage the full execution lifecycle.

How do I classify task independence before firing parallel workflows?

Task independence classification is supported within the workflow to ensure tasks can be executed concurrently. You must verify tasks have no dependencies before firing them to executor agents to maximize throughput.