ultrawork

Dispatch independent subtasks to multiple agents across tiers for parallel execution.

Updated Jul 3, 2025
One-click install
npx skills add https://github.com/andrew-t-james/dotfiles --skill ultrawork-andrew-t-james
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ultrawork
Source: https://github.com/andrew-t-james/dotfiles/tree/main/dot_codex/skills/ultrawork
Command: npx skills add https://github.com/andrew-t-james/dotfiles --skill ultrawork-andrew-t-james

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Ultrawork provides parallel execution for high-throughput tasks by dispatching independent subtasks to multiple agents at suitable model tiers, without handling persistence or state management.

Core Features & Use Cases

  • Fire independent agent calls simultaneously and route each to the correct tier (LOW, STANDARD, THOROUGH).
  • Read guidance on tier selection before delegation to optimize cost and performance.
  • Use run_in_background for long-running operations while quick tasks proceed in the foreground.
  • Verify when all tasks complete and ensure lightweight checks pass.

Quick Start

Invoke ultrawork to dispatch multiple independent tasks to suitable agent tiers for parallel execution.

Frequently Asked Questions about ultrawork

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

FAQPage Schema
How do I run parallel tasks across multiple agents concurrently?

Parallel execution dispatches independent subtasks simultaneously to multiple agents at appropriate model tiers. It applies when you have several independent subtasks that can run concurrently, allowing you to manage completion yourself while optimizing cost and performance through tier selection.

How do I choose the right agent tier for background task delegation?

Choosing the right agent tier involves reading the agent-tier guidance before delegation to optimize cost and performance. You route each independent subtask to the LOW, STANDARD, or THOROUGH tier based on its complexity and required execution depth.

What is the best way to execute long-running operations without blocking foreground tasks?

The best way to execute long-running operations without blocking foreground tasks is using run_in_background during delegation. This dispatches lengthy operations to background agents while quick tasks proceed in the foreground, maximizing concurrency and throughput.

Does parallel task execution handle state management and persistence?

Parallel task execution does not handle state management or persistence. It strictly provides high-throughput execution by dispatching independent subtasks to multiple agents, leaving persistence and state management entirely to the user who manages task completion themselves.

When should I not use concurrent agent delegation for task execution?

You should not use concurrent agent delegation when subtasks are dependent on each other. This parallel execution approach applies only when you have several independent subtasks that can run concurrently without interaction, as it lacks built-in state management for coordinating dependencies.