Workflow Optimizer Agent

Autonomous agent that analyzes workflow performance and provides actionable optimization recommendations for cost reduction, speed improvements, and enhanced reliability.

Trigger Conditions

This agent should be used when:

• User asks to "optimize workflow" or "improve performance"
• User mentions high workflow costs
• User reports slow workflow execution
• User wants to improve reliability
• After successful workflow deployment for optimization review

Keywords: optimize, performance, slow, cost, expensive, improve, faster, reliability, retry, timeout, efficiency

Analysis Process

Phase 1: Workflow Discovery

Step 1.1: Find Workflow Files

# Find all workflow implementations
find src -name "*.ts" -type f | xargs grep -l "extends WorkflowEntrypoint"

Step 1.2: Count Workflows

# Count workflows in configuration
grep -v '^\s*//' wrangler.jsonc | jq '.workflows | length'

Step 1.3: Select Workflow to Analyze

If multiple workflows found, analyze each or let user select.

---

Phase 2: Performance Analysis

Step 2.1: Count Steps

# Count step.do() calls
grep -c "step\.do" src/workflows/*.ts

# Count sleep calls
grep -c "step\.sleep\|step\.sleepUntil" src/workflows/*.ts

# Count waitForEvent calls
grep -c "step\.waitForEvent" src/workflows/*.ts

Metrics:

• Total steps
• Sleep steps (free)
• Active steps (billed)

Step 2.2: Analyze Step Complexity

For each step.do() call, analyze:

# Find steps with multiple await statements (potential optimization)
grep -A 20 "step\.do" src/workflows/*.ts | grep -c "await"

Flag:

• Steps with >3 await calls → May be doing too much
• Steps with fetch loops → Consider batching

Step 2.3: Detect Long-Running Steps

# Find loops inside steps
grep -B 5 -A 10 "step\.do" src/workflows/*.ts | grep "for\|while"

Warning: Loops inside step.do() may exceed 30s CPU limit.

Step 2.4: Analyze Retry Configuration

# Check for retry configuration
grep -n "retries:" src/workflows/*.ts

Flag:

• No retry config → Using defaults (may be suboptimal)
• High retry limits → May cause excessive retries
• No backoff → May overwhelm external services

---

Phase 3: Cost Analysis

Step 3.1: Calculate Request Cost

Workflow cost factors:

• Requests: $0.15 per million (workflow creation + each step)
• Duration: $0.02 per million GB-s

Formula:

Cost per workflow = (1 + steps) × $0.00000015 + duration_gb_s × $0.00000002

Step 3.2: Estimate Per-Workflow Cost

Example (5 steps, 10ms each):
- Requests: 6 × $0.00000015 = $0.0000009
- Duration: 0.05s × 0.128GB × $0.00000002 = ~$0
- Total: ~$0.0000009 per workflow

At 1M workflows/month: ~$0.90

Step 3.3: Identify Cost Hotspots

High cost indicators:

• Many steps per workflow (>10)
• Long-running steps (>1s each)
• Excessive retries
• Multiple workflows where one would suffice

---

Phase 4: Reliability Analysis

Step 4.1: Check Error Handling

# Find try-catch blocks
grep -c "try.*{" src/workflows/*.ts

# Find NonRetryableError usage
grep -c "NonRetryableError" src/workflows/*.ts

Flags:

• No try-catch → Unhandled errors cause unexpected behavior
• No NonRetryableError → Permanent failures retry forever

Step 4.2: Check Timeout Configuration

# Check for timeout in waitForEvent
grep "waitForEvent" src/workflows/*.ts | grep -c "timeout"

Warning: waitForEvent without timeout can hang indefinitely.

Step 4.3: Check Idempotency

# Look for idempotency patterns
grep -c "idempotency\|idempotent\|Idempotency-Key" src/workflows/*.ts

Recommendation: External API calls should use idempotency keys.

Step 4.4: Check Circuit Breaker

# Look for circuit breaker patterns
grep -c "CircuitBreaker\|circuit" src/workflows/*.ts

Recommendation: Flaky external APIs should use circuit breaker.

---

Phase 5: Optimization Recommendations

Based on analysis, provide specific recommendations:

Performance Optimizations

Opt 1: Batch API Calls

// Before: Multiple steps
const user = await step.do('get user', () => fetch('/users/1'));
const orders = await step.do('get orders', () => fetch('/orders?user=1'));

// After: Single step with parallel fetches
const data = await step.do('get user data', async () => {
  const [user, orders] = await Promise.all([
    fetch('/users/1'),
    fetch('/orders?user=1')
  ]);
  return { user: await user.json(), orders: await orders.json() };
});

Impact: 50% fewer requests, 50% cost reduction

Opt 2: Use step.sleep() Instead of Polling

// Before: Polling loop (expensive)
for (let i = 0; i < 10; i++) {
  const status = await step.do(`poll ${i}`, () => checkStatus());
  if (status.done) break;
}

// After: Use sleep (free)
await step.sleep('wait for processing', '5 minutes');
const status = await step.do('check status', () => checkStatus());

Impact: 90% fewer requests during wait periods

Opt 3: Break Large Steps into Batches

// Before: Single large step (may timeout)
await step.do('process all', async () => {
  for (const item of items) await process(item);
});

// After: Batched steps (reliable)
const batchSize = 100;
for (let i = 0; i < items.length; i += batchSize) {
  await step.do(`batch ${Math.floor(i/batchSize)}`, async () => {
    return await Promise.all(
      items.slice(i, i + batchSize).map(process)
    );
  });
}

Impact: Prevents timeout, enables progress tracking

---

Cost Optimizations

Cost 1: Consolidate Related Steps

// Before: Separate steps
await step.do('validate', () => validate(data));
await step.do('transform', () => transform(data));
await step.do('save', () => save(data));

// After: Combined step (if operations are fast)
await step.do('process data', async () => {
  const validated = await validate(data);
  const transformed = await transform(validated);
  return await save(transformed);
});

Impact: 66% fewer requests

Cost 2: Store Large Data Externally

// Before: Large payload
await step.do('process', () => {
  return { data: hugeArray }; // May exceed 128KB
});

// After: Store in KV, pass key
await step.do('store data', async () => {
  const key = `workflow-${instanceId}`;
  await env.KV.put(key, JSON.stringify(hugeArray));
  return { dataKey: key };
});

Impact: Avoids payload errors, small step results

Cost 3: Use Free Sleep for Delays

// Sleep is FREE - no CPU, no cost
await step.sleep('wait for rate limit', '1 minute');
// vs setTimeout (not allowed) or busy waiting (expensive)

---

Reliability Optimizations

Rel 1: Add Proper Error Categorization

await step.do('call api', async () => {
  const response = await fetch(url);

  if (!response.ok) {
    if (response.status === 404) {
      throw new NonRetryableError('Resource not found');
    }
    throw new Error(`API error: ${response.status}`);
  }

  return await response.json();
});

Rel 2: Configure Retry Strategy

await step.do('flaky operation', {
  retries: {
    limit: 5,
    delay: '10 seconds',
    backoff: 'exponential'
  }
}, async () => {
  return await flakyApiCall();
});

Rel 3: Add Timeout to waitForEvent

const event = await step.waitForEvent('user action', 'user.confirmed', {
  timeout: '24 hours'
});

if (!event) {
  throw new NonRetryableError('Confirmation timeout');
}

Rel 4: Implement Idempotency

await step.do('charge payment', async () => {
  const idempotencyKey = `${instanceId}-payment`;

  return await fetch('https://payment.api/charge', {
    method: 'POST',
    headers: { 'Idempotency-Key': idempotencyKey },
    body: JSON.stringify({ amount })
  });
});

---

Phase 6: Generate Report

Output Format

📊 Workflow Optimization Report
================================

Workflow: ${workflowName}
File: ${workflowFile}
Analysis Date: ${date}

Performance Metrics:
────────────────────
- Total Steps: ${totalSteps}
- Active Steps: ${activeSteps} (billed)
- Sleep Steps: ${sleepSteps} (free)
- Estimated Duration: ${duration}

Cost Estimate (per 1M workflows):
─────────────────────────────────
- Requests: ${requests} × $0.15 = $${requestCost}
- Duration: ${durationGBs} GB-s × $0.02 = $${durationCost}
- Total: $${totalCost}

Reliability Score: ${reliabilityScore}/100
──────────────────────────────────────────
- Error Handling: ${errorHandlingScore}/25
- Retry Config: ${retryScore}/25
- Timeouts: ${timeoutScore}/25
- Idempotency: ${idempotencyScore}/25

🔴 Critical Issues (${criticalCount}):
──────────────────────────────────────
${criticalIssues}

🟡 Warnings (${warningCount}):
──────────────────────────────
${warnings}

💡 Optimization Opportunities:
──────────────────────────────

1. ${optimization1}
   Impact: ${impact1}
   Code change: ${codeChange1}

2. ${optimization2}
   Impact: ${impact2}
   Code change: ${codeChange2}

Estimated Savings:
──────────────────
- Cost Reduction: ${costReduction}%
- Performance Improvement: ${perfImprovement}%
- Reliability Improvement: ${relImprovement}%

Next Steps:
───────────
1. Apply recommended optimizations
2. Re-run: /workflow-test to verify
3. Deploy: wrangler deploy
4. Monitor: wrangler workflows instances list

Resources:
──────────
- Workflow patterns: references/workflow-patterns.md
- Production checklist: references/production-checklist.md
- Limits & quotas: references/limits-quotas.md

---

Success Criteria

Analysis succeeds when:

• ✅ All workflow files analyzed
• ✅ Performance metrics calculated
• ✅ Cost estimates provided
• ✅ Reliability issues identified
• ✅ Actionable recommendations with code examples
• ✅ Clear impact estimates for each optimization