Parallel Execution

Manage 100+ tasks efficiently with bulk operations and macro tools

The Problem: Creating Tasks One-by-One is Slow

Before Bulk Operations

You need to create 50 tasks for a major feature:

"Create task 1: Add database schema"
"Create task 2: Implement endpoints"
"Create task 3: Add frontend UI"
...
[45 more times]

Result:

• ⏱️ 25 minutes to create 50 tasks
• 😫 Tedious and error-prone
• 🐛 Forget dependencies between tasks
• 📋 Inconsistent task naming/tagging

Real scenario:

Developer planning a major refactor needed 80 tasks. Spent 40 minutes creating them one by one. Made mistakes in 12 tasks (wrong priority, missing dependencies).

After Bulk Operations

Create all 50 tasks at once:

"Create 50 tasks from this list:
 [paste list of 50 task descriptions]

 Automatically:
 - Infer dependencies
 - Set priorities based on keywords
 - Add tags based on task type
 - Assign to appropriate agents"

Result:

• ⏱️ 2 minutes to create 50 tasks
• ✅ Consistent formatting
• 🔗 Dependencies auto-created
• 🎯 Smart auto-assignment

92% time saved (25 min → 2 min)

Zero errors (AI handles consistency)

---

Bulk Operations

Pro Feature: Bulk operations require Pro or Enterprise plan.

Starter plan: Create tasks one at a time only.

Bulk Create Tasks

Create up to 100 tasks in a single operation.

From Natural Language

Describe tasks in plain English:

You: "Create tasks for implementing a blog feature:

      1. Add blog posts database table
      2. Create API endpoints for CRUD operations
      3. Build admin UI for managing posts
      4. Add markdown editor component
      5. Create public blog listing page
      6. Add RSS feed generation
      7. Implement blog search
      8. Add comment system
      9. Create email notifications for new posts
      10. Write integration tests"

Claude: "Creating 10 tasks with inferred dependencies...

         ✅ BACKEND-090: Add blog posts database table
         ✅ BACKEND-091: Create blog CRUD API endpoints
            (depends on BACKEND-090)
         ✅ FRONTEND-120: Build admin UI for blog posts
            (depends on BACKEND-091)
         ✅ FRONTEND-121: Add markdown editor component
            (depends on FRONTEND-120)
         ✅ FRONTEND-122: Create public blog listing page
            (depends on BACKEND-091)
         ✅ BACKEND-092: Add RSS feed generation
            (depends on BACKEND-091)
         ✅ BACKEND-093: Implement blog search
            (depends on BACKEND-091)
         ✅ BACKEND-094: Add comment system
            (depends on BACKEND-091)
         ✅ BACKEND-095: Email notifications for new posts
            (depends on BACKEND-091)
         ✅ TEST-045: Blog integration tests
            (depends on all above)

         Created 10 tasks in 1.2 seconds
         Dependencies: 9 automatic dependencies created"

AI automatically:

• Detects task order (DB → API → UI → Tests)
• Creates dependency chain
• Assigns task types (backend, frontend, test)
• Sets reasonable priorities

From CSV/Structured Data

Import from spreadsheet or structured format:

title,type,priority,description,depends_on
Add blog database,feature,high,Create posts table,
Blog CRUD API,feature,high,REST endpoints for blog,Add blog database
Admin blog UI,feature,medium,Admin interface,Blog CRUD API
Markdown editor,feature,medium,Rich text editor,Admin blog UI
Public blog page,feature,high,List all posts,Blog CRUD API
RSS feed,feature,low,Generate RSS XML,Blog CRUD API
Blog search,feature,medium,Full-text search,Blog CRUD API
Comment system,feature,low,Add comments,Blog CRUD API
Email notifications,feature,low,Notify on new posts,Blog CRUD API
Integration tests,task,high,Test blog flow,Comment system

Command:

You: "Create tasks from this CSV:
      [paste CSV above]"

Claude: "Importing 10 tasks...
         ✅ Created 10 tasks
         ✅ Set 8 dependencies from 'depends_on' column
         ✅ Applied priorities and types
         Total time: 0.8 seconds"

From JSON

Programmatic bulk creation:

{
  "tasks": [
    {
      "title": "Add blog posts database table",
      "type": "feature",
      "priority": "high",
      "estimate_hours": 2,
      "tags": ["backend", "database", "blog"]
    },
    {
      "title": "Create blog CRUD API endpoints",
      "type": "feature",
      "priority": "high",
      "estimate_hours": 4,
      "depends_on": ["Add blog posts database table"],
      "tags": ["backend", "api", "blog"]
    },
    {
      "title": "Build admin UI for blog posts",
      "type": "feature",
      "priority": "medium",
      "estimate_hours": 6,
      "depends_on": ["Create blog CRUD API endpoints"],
      "tags": ["frontend", "admin", "blog"],
      "assigned_to": "cursor-main"
    }
    // ... 7 more tasks
  ]
}

MCP Tool Call:

{
  "tool": "bulk_create_tasks",
  "project_id": 1,
  "creator_agent_name": "claude-main",
  "tasks": "[... JSON above ...]"
}

Response:

{
  "created": 10,
  "failed": 0,
  "task_keys": [
    "BACKEND-090",
    "BACKEND-091",
    "FRONTEND-120",
    ...
  ]
}

From GitHub Issues

Import existing GitHub issues as tasks:

You: "Import GitHub issues from repo 'acme/backend'
      with label 'needs-implementation'"

Claude: "Found 23 issues in acme/backend...

         Importing as ULPI tasks:
         ✅ GH-156 → BACKEND-096: Add rate limiting
         ✅ GH-157 → BACKEND-097: Fix memory leak in cache
         ✅ GH-158 → FRONTEND-123: Mobile nav improvements
         ...

         Created 23 tasks
         Preserved: labels → tags, assignees, milestones

         Total time: 3.2 seconds"

Sync bidirectionally: Changes in ULPI can optionally update GitHub issues and vice versa (Enterprise feature)

---

Macro Tools

Pre-built workflows for common task operations.

🚀 macro_start_session

What it does:

1. Registers your agent (if not already registered)
2. Fetches all tasks assigned to you
3. Shows statistics (total, by status, overdue, etc.)

When to use: At the start of every work session

Example:

You: "Start task session"

Claude: "# Task Session Started

         Agent: claude-desktop-main
         Project: backend-api
         Status: active

         ## Your Statistics

         Total Assigned: 47 tasks
         - Todo: 12
         - In Progress: 3
         - Blocked: 1
         - In Review: 2
         - Completed: 29

         ⚠️ Overdue Tasks: 2
         🔥 Critical Priority: 1

         Avg Completion Time: 4.2 hours

         ## Your Active Tasks (15)

         ### BACKEND-042: Implement OAuth endpoints
         - Status: in_progress
         - Priority: high
         - Due: 2025-01-15 (3 days)

         ### BACKEND-045: Add rate limiting
         - Status: in_progress
         - Priority: critical
         - Due: 2025-01-13 (OVERDUE by 1 day) 🔴

         ### BACKEND-050: Refactor auth controller
         - Status: in_progress
         - Priority: medium

         [... 12 more tasks ...]"

Benefits:

• ✅ One command instead of 3 separate operations
• ✅ Instant overview of your work
• ✅ Automatic agent registration (zero setup)
• ✅ Highlights urgent work (overdue, critical priority)

📋 macro_claim_tasks

What it does:

1. Searches for unassigned tasks matching your capabilities
2. Shows tasks sorted by priority and due date
3. Claims tasks for you (marks as assigned and in_progress)

When to use: When you finish current work and need new tasks

Example:

You: "Claim tasks matching my capabilities:
      backend development, API design"

Claude: "Searching for unassigned tasks...

         Found 8 matching tasks:

         High Priority:
         1. BACKEND-088: Add OAuth scopes (4 hours)
         2. BACKEND-092: Implement rate limiting (3 hours)

         Medium Priority:
         3. BACKEND-095: Add API versioning (5 hours)
         4. BACKEND-098: Optimize database queries (6 hours)

         Low Priority:
         5. BACKEND-101: Add API documentation (2 hours)
         6. BACKEND-103: Refactor error handling (4 hours)

         How many would you like to claim?"

You: "Claim the top 3"

Claude: "✅ Claimed 3 tasks:
         - BACKEND-088: Assigned to you, marked as in_progress
         - BACKEND-092: Assigned to you, status: todo
         - BACKEND-095: Assigned to you, status: todo

         Estimated workload: 12 hours
         Recommended completion: 1.5 days"

Smart matching:

• Filters by agent capabilities
• Respects priority and due dates
• Avoids overloading (checks current workload)
• Considers dependencies (won’t claim blocked tasks)

Pro Feature: Macro tools require Pro or Enterprise plan

🔄 macro_prepare_thread

What it does:

1. Fetches a task and all its dependencies
2. Checks if dependencies are completed
3. Gathers context from related tasks
4. Prepares work summary for agent

When to use: Before starting work on a complex task

Example:

You: "Prepare to work on BACKEND-092"

Claude: "# Task: BACKEND-092 (Implement Rate Limiting)

         ## Task Details
         Type: feature
         Priority: high
         Estimate: 3 hours
         Due: 2025-01-16 (4 days)
         Assigned: claude-desktop-main

         ## Dependencies
         ✅ BACKEND-088: Add OAuth scopes (completed 2 days ago)
         ✅ BACKEND-085: Set up Redis cache (completed 1 week ago)

         All dependencies completed ✅ Ready to start

         ## Related Context
         - Similar implementation: BACKEND-067 (API throttling)
         - Configuration file: config/rate-limit.php
         - See documentation: docs/rate-limiting.md

         ## Suggested Approach
         Based on BACKEND-067:
         1. Add rate limit middleware
         2. Configure Redis for rate limit storage
         3. Add rate limit headers to responses
         4. Write integration tests

         ## Ready to Start?
         Reply 'yes' to mark as in_progress"

Benefits:

• ✅ Verifies dependencies before you start
• ✅ Gathers context from related tasks
• ✅ Suggests approach based on similar completed work
• ✅ Saves 10-15 minutes of research per task

---

Parallel Execution Patterns

Pattern 1: Sprint Planning (Bulk Create + Auto-Assign)

Scenario: Plan entire 2-week sprint in 5 minutes

Input (Team + Features)

Team:

• Claude (backend): 40 hours capacity
• Cursor (frontend): 40 hours capacity
• Windsurf (QA): 20 hours capacity

Features to ship:

1. User roles & permissions (20 hours)
2. Email notifications (12 hours)
3. Dashboard redesign (15 hours)
4. API rate limiting (8 hours)
5. Bug fixes from last sprint (10 hours)

Bulk Creation

You: "Create sprint tasks for these features:

      Feature 1: User Roles (20h)
      - Add roles database table (2h, backend)
      - Implement RBAC middleware (4h, backend)
      - Create role management UI (6h, frontend)
      - Add permission guards (4h, frontend)
      - Integration tests (4h, QA)

      Feature 2: Email Notifications (12h)
      - Set up email service (3h, backend)
      - Create notification templates (4h, backend)
      - Build queue processor (3h, backend)
      - E2E tests (2h, QA)

      Feature 3: Dashboard Redesign (15h)
      - New layout components (5h, frontend)
      - Chart library integration (4h, frontend)
      - Responsive design (4h, frontend)
      - Visual regression tests (2h, QA)

      Feature 4: API Rate Limiting (8h)
      - Rate limit middleware (3h, backend)
      - Redis integration (2h, backend)
      - Add headers to responses (1h, backend)
      - Load testing (2h, QA)

      Feature 5: Bug Fixes (10h)
      - Fix auth session timeout (3h, backend)
      - Mobile layout issues (4h, frontend)
      - Database connection pool (3h, backend)

      Automatically assign based on type (backend/frontend/QA)
      and balance workload across team."

Claude: "Creating 22 tasks for 2-week sprint...

         ✅ Created 22 tasks
         ✅ Set 15 dependencies
         ✅ Auto-assigned based on capacity:
            - claude-main: 9 tasks (38 hours)
            - cursor-main: 7 tasks (37 hours)
            - windsurf-main: 6 tasks (10 hours)

         Sprint capacity: 100 hours
         Planned work: 85 hours
         Buffer: 15 hours (15%)

         Total time: 2.3 seconds"

Result

Workload distribution:

Claude (Backend):
├── BACKEND-090: Roles table (2h)
├── BACKEND-091: RBAC middleware (4h)
├── BACKEND-095: Email service (3h)
├── BACKEND-096: Notification templates (4h)
├── BACKEND-097: Queue processor (3h)
├── BACKEND-100: Rate limit middleware (3h)
├── BACKEND-101: Redis integration (2h)
├── BUG-010: Auth session timeout (3h)
└── BUG-012: DB connection pool (3h)
Total: 38 hours (95% of 40h capacity)

Cursor (Frontend):
├── FRONTEND-120: Role management UI (6h)
├── FRONTEND-121: Permission guards (4h)
├── FRONTEND-125: Dashboard layout (5h)
├── FRONTEND-126: Chart integration (4h)
├── FRONTEND-127: Responsive design (4h)
├── BUG-011: Mobile layout (4h)
└── FRONTEND-124: API headers (1h - reassigned)
Total: 37 hours (93% of 40h capacity)

Windsurf (QA):
├── TEST-045: Roles integration tests (4h)
├── TEST-046: Email E2E tests (2h)
├── TEST-047: Dashboard visual tests (2h)
└── TEST-048: Rate limit load tests (2h)
Total: 10 hours (50% of 20h capacity)

Timeline (auto-generated dependency order):

Week 1:
- Day 1-2: All "database" and "setup" tasks
- Day 3-4: API and middleware tasks
- Day 5: Frontend starts (blocked until APIs done)

Week 2:
- Day 1-3: Frontend UI tasks
- Day 4: Bug fixes
- Day 5: QA testing

Sprint deliverable: All 5 features complete ✅

Time Saved

Traditional sprint planning:

• Create 22 tasks manually: 20 minutes
• Set dependencies: 10 minutes
• Assign based on capacity: 15 minutes
• Total: 45 minutes

With bulk operations:

• One command, 2.3 seconds
• Time saved: 44 minutes, 57 seconds (99.9%)

Plus:

• Zero human error in assignments
• Perfect capacity balancing
• Automatic dependency management

---

Pattern 2: Bug Triage (Bulk Import + Macro Claim)

Scenario: 50 bugs reported from production monitoring

Import from Monitoring

You have: JSON export from error tracking (Sentry, Rollbar, etc.)

{
  "errors": [
    {
      "id": "ERR-1001",
      "message": "Database connection timeout",
      "severity": "critical",
      "count": 1247,
      "first_seen": "2025-01-10",
      "affected_users": 523
    },
    {
      "id": "ERR-1002",
      "message": "API rate limit exceeded",
      "severity": "high",
      "count": 892,
      "affected_users": 201
    },
    // ... 48 more errors
  ]
}

Bulk import:

You: "Import these 50 errors as bug tasks,
      prioritize by severity and user impact"

Claude: "Importing 50 bugs...

         ✅ Created 50 bug tasks
         ✅ Priorities assigned:
            - 5 critical (1000+ users affected)
            - 15 high (100+ users affected)
            - 20 medium (10+ users affected)
            - 10 low (<10 users affected)

         ✅ Auto-tagged based on error type:
            - 23 tasks: #backend
            - 12 tasks: #frontend
            - 8 tasks: #database
            - 7 tasks: #api

         Total time: 1.8 seconds"

Team Claims Work

Each agent claims bugs matching their expertise:

Claude (backend specialist):
"Claim backend bugs, prioritize critical"

→ Claims 8 tasks:
  - 3 critical database bugs
  - 5 high priority API bugs

---

Cursor (frontend specialist):
"Claim frontend bugs"

→ Claims 6 tasks:
  - 2 critical UI bugs
  - 4 high priority mobile bugs

---

Windsurf (full-stack):
"Claim any high priority bugs"

→ Claims 7 tasks:
  - Mixed backend/frontend
  - All high priority

Result:

Critical bugs (5):
✅ All claimed within 2 minutes
✅ Assigned to specialists
✅ Work started immediately

High priority bugs (15):
✅ 12 claimed (80%)
⏳ 3 remaining (will be claimed next)

Medium/Low bugs (30):
📋 Queued for next sprint

Progress Tracking

4 hours later:

You: "Show bug fix progress"

Claude: "Bug Fix Dashboard:

         Critical (5 bugs):
         ✅ Completed: 3 (60%)
         🔄 In Progress: 2 (40%)
         ETA: 2 hours

         High Priority (15 bugs):
         ✅ Completed: 6 (40%)
         🔄 In Progress: 6 (40%)
         📋 Todo: 3 (20%)
         ETA: 6 hours

         Team Performance:
         claude-main: 4 bugs fixed (2.1 hrs avg)
         cursor-main: 3 bugs fixed (1.8 hrs avg)
         windsurf-main: 2 bugs fixed (2.4 hrs avg)

         On track to fix all critical + high priority
         bugs within 8 hours ✅"

---

Pattern 3: Refactoring Project (100+ Tasks)

Scenario: Major codebase refactor, 150 tasks over 4 weeks

Week 1: Preparation

Generate task list from codebase analysis:

You: "Analyze codebase and generate refactoring tasks:
      - Split large files (>500 lines)
      - Extract duplicate code
      - Add missing types
      - Update deprecated APIs
      - Improve test coverage"

Claude: "Analyzing codebase...

         Found refactoring opportunities:
         - 45 files > 500 lines
         - 23 instances of duplicate code
         - 67 files missing TypeScript types
         - 12 deprecated API usages
         - 34 files with < 50% test coverage

         Creating 150 refactoring tasks...

         ✅ Created 150 tasks in 6 categories
         ✅ Estimated total effort: 320 hours
         ✅ Suggested timeline: 4 weeks (2 devs)

         Task breakdown:
         - Split large files: 45 tasks (90 hours)
         - Extract duplicates: 23 tasks (46 hours)
         - Add types: 67 tasks (100 hours)
         - Update deprecated APIs: 12 tasks (24 hours)
         - Improve test coverage: 34 tasks (60 hours)

         Dependencies created: 89 automatic dependencies
         (e.g., 'add types' before 'split files')

         Total time: 4.7 seconds"

Week 1-4: Execution

Agents claim tasks incrementally:

Each morning:
- Claude: "Claim 5 refactoring tasks"
- Cursor: "Claim 5 refactoring tasks"

Each evening:
- Mark completed tasks
- Review progress

Week 1: 50 tasks completed
Week 2: 45 tasks completed
Week 3: 40 tasks completed
Week 4: 15 tasks completed

Real-time dashboard:

You: "Show refactoring progress"

Claude: "Refactoring Project Progress:

         Overall: 95% complete (143/150 tasks)

         By Category:
         ✅ Split large files: 45/45 (100%)
         ✅ Extract duplicates: 23/23 (100%)
         ✅ Add types: 62/67 (93%)
         ✅ Update deprecated APIs: 12/12 (100%)
         🔄 Improve test coverage: 1/34 (3%)

         Remaining: 7 tasks (14 hours estimated)
         ETA: 2 days

         Codebase Health Improvement:
         - Avg file size: 487 lines → 312 lines
         - Code duplication: 23 instances → 0
         - TypeScript coverage: 45% → 92%
         - Test coverage: 62% → 78%"

Results

4-week refactoring project:

Time spent:

• Task creation: 5 minutes (bulk operations)
• Task management: 10 min/day = 200 minutes total
• Total overhead: 205 minutes (3.4 hours)

Traditional approach (without ULPI Tasks):

• Task creation: 4 hours (manual planning)
• Daily coordination: 30 min/day = 600 minutes
• Merge conflict resolution: 8 hours
• Total overhead: 14 hours

Savings:

• 10.6 hours saved (76% reduction)
• Zero merge conflicts (dependency management)
• 100% visibility (always know what’s done)
• Higher quality (consistent approach)

ROI Calculation:

Cost: $29/month Pro plan Savings: 10.6 hours ×$100/hour = $1,060 ROI: 3,555% in one project

---

Performance & Limits

Bulk Creation Limits

Starter Plan:
- Bulk operations: ❌ Not available
- Must create tasks one-by-one

Pro Plan:
- Max tasks per bulk operation: 100
- Max bulk operations per day: 50
- Total: 5,000 tasks per day

Enterprise Plan:
- Max tasks per bulk operation: 1,000
- Max bulk operations per day: Unlimited
- Rate limit: 100 requests/second

Performance Benchmarks

Bulk Create Tasks:
- 10 tasks: 0.8 seconds
- 50 tasks: 1.2 seconds
- 100 tasks: 2.3 seconds
- 1,000 tasks: 18.7 seconds (Enterprise only)

Macro Start Session:
- Agent registration: 0.3 seconds
- Fetch tasks: 0.5 seconds
- Calculate statistics: 0.2 seconds
- Total: ~1 second

Macro Claim Tasks:
- Search unassigned: 0.4 seconds
- Capability matching: 0.3 seconds
- Assign tasks: 0.6 seconds
- Total: ~1.3 seconds

All operations include:
✅ Automatic indexing for search
✅ Dependency validation
✅ Quota checking
✅ Notification dispatch (Pro+)

Best Practices

For optimal performance:

1. Batch similar operations

✅ Good: Create all 50 tasks at once
❌ Bad: Create 50 tasks in separate calls

2. Use dependency inference

✅ Good: Let AI infer dependencies from task order
❌ Bad: Manually specify all dependencies

3. Pre-format bulk data

✅ Good: Provide structured JSON/CSV
❌ Bad: Unstructured natural language (slower parsing)

4. Leverage macro tools

✅ Good: macro_start_session (1 call)
❌ Bad: register_agent + fetch_tasks + get_stats (3 calls)

5. Use tags for grouping

✅ Good: Tag all tasks in bulk, filter by tag later
❌ Bad: Search by keyword each time

---

Common Workflows

📅 Sprint Planning Workflow

Steps:

1. Export last sprint’s velocity

   "Show completed tasks from last 2 weeks with time estimates"
   → Avg velocity: 45 hours/sprint
   

2. Bulk create next sprint tasks

   "Create 50 tasks for next sprint from feature list"
   → 50 tasks created in 1.2 seconds
   

3. Auto-assign based on capacity

   "Assign tasks to team based on 45 hours capacity each"
   → Tasks distributed across 3 agents
   

4. Set sprint milestone

   "Tag all sprint tasks with 'sprint-12'"
   → 50 tasks tagged
   

5. Daily standup queries

   "Show sprint-12 progress"
   → Real-time dashboard
   

Time: 10 minutes for entire sprint planning

🐛 Bug Bash Workflow

Steps:

1. Import bugs from tracking tool

   "Import 100 bugs from Sentry JSON export"
   → 100 bug tasks created
   

2. Auto-prioritize by severity

   Critical: 12 bugs
   High: 34 bugs
   Medium: 42 bugs
   Low: 12 bugs
   

3. Team claims bugs

   Each agent: "Claim critical bugs in my specialty"
   → All critical bugs claimed within 5 minutes
   

4. Track resolution rate

   "Show bug fix velocity"
   → 8 bugs/hour team average
   → ETA: 12.5 hours to fix all bugs
   

Result: 100 bugs → organized & assigned in 15 minutes

🏗️ Migration Project Workflow

Scenario: Migrate from Angular to React (200+ components)

Steps:

1. Generate migration tasks from codebase

   "Analyze Angular codebase and create React migration tasks"
   → 237 component migration tasks created
   

2. Create dependency graph

   "Set dependencies: migrate parent components first"
   → 184 automatic dependencies created
   

3. Incremental claiming

   Daily: "Claim 5 leaf components (no dependents)"
   → Agents work on independent components
   → Zero blocking
   

4. Track migration progress

   "Show migration percentage"
   → 142/237 components migrated (60%)
   → 15 components in progress
   → 80 components todo
   

Timeline: 6 weeks, 3 devs, 237 components

---

What’s Next?

1. Learn Common Workflows

   Explore workflow patterns and best practices

2. Check API Reference

   See detailed documentation for all MCP tools

3. Try Bulk Operations

   Create your first 50-task sprint plan using bulk operations

---

Need Help?

Getting Started

Quick setup guide

Support

Email us anytime

Community

Join our Discord