> ## Documentation Index
> Fetch the complete documentation index at: https://ulpi.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Parallel Execution
> Manage 100+ tasks efficiently with bulk operations and macro tools
## The Problem: Creating Tasks One-by-One is Slow
**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).
**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.**
**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
**Import from spreadsheet or structured format:**
```csv theme={null}
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"
```
**Programmatic bulk creation:**
```json theme={null}
{
"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:**
```json theme={null}
{
"tool": "bulk_create_tasks",
"project_id": 1,
"creator_agent_name": "claude-main",
"tasks": "[... JSON above ...]"
}
```
**Response:**
```json theme={null}
{
"created": 10,
"failed": 0,
"task_keys": [
"BACKEND-090",
"BACKEND-091",
"FRONTEND-120",
...
]
}
```
**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.**
**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)
**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
**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
**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)
```
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"
```
**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 ✅
```
**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
**You have:** JSON export from error tracking (Sentry, Rollbar, etc.)
```json theme={null}
{
"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"
```
**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
```
**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
**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"
```
**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%"
```
**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
```
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
```
```
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+)
```
**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
**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
**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
**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?
[Explore workflow patterns and best practices](/tasks/workflows)
[See detailed documentation for all MCP tools](/tasks/api-reference)
Create your first 50-task sprint plan using bulk operations
***
## Need Help?
Quick setup guide
Email us anytime
Join our Discord