Building automation with LLMs is fundamentally different from traditional scripting. You're not writing rigid logic—you're setting up intelligent agents that adapt to new situations, understand context, and make nuanced decisions.

This guide covers the patterns that separate working prototypes from production-grade automation.

The Paradigm Shift: From Logic to Reasoning

LLM-powered workflows prioritize reasoning over rigid logic paths

Traditional automation uses flowcharts: if X, then Y. LLM automation works differently. Instead of rigid conditions, you describe a goal and let Claude reason about the best approach.

Traditional:

• Customer cancels → send template 3 → mark inactive
• Works 95% of the time, breaks when situation is unusual

LLM-powered:

• Customer requests cancellation → Claude analyzes request and response with empathy
• Offers alternatives, retention incentives, or graceful exit
• Works in 95%+ of situations, adapts to context

The shift requires rethinking your automation architecture.

Workflow Pattern 1: Input → Analysis → Action

The canonical pattern for intelligent automation: receive input, analyze with Claude, execute action

Every LLM automation follows this core pattern:

Input (email, form, file) 
  ↓
Claude analysis (understand intent, extract data, reason about next step)
  ↓
Action (send response, trigger tool, update system)

Example: Processing support emails

async function processEmail(email) {
  // INPUT: Get the email
  const content = email.body;
  
  // ANALYSIS: Claude understands the issue
  const analysis = await claude.ask(`
    Analyze this support email:
    - What is the customer's main issue?
    - What information are we missing?
    - What should we do next?
    
    Email: ${content}
  `);
  
  // ACTION: Execute based on analysis
  if (analysis.includes("missing info")) {
    sendEmail(email.from, "We need more details...");
  } else if (analysis.includes("bug")) {
    createBugTicket(analysis.details);
  } else {
    sendResponse(analysis.suggestedResponse);
  }
}

This pattern applies everywhere: customer requests, content moderation, data classification, research summarization.

Workflow Pattern 2: Multi-Step Reasoning with State

Complex workflows maintain state and route to different steps based on reasoning

Real workflows have multiple stages. Use Claude to determine which step comes next:

const workflow = {
  stages: {
    analyze: "Understand the request",
    enrichData: "Gather additional context",
    validate: "Check feasibility",
    execute: "Perform the action",
    confirm: "Report results"
  },
  
  async run(input) {
    let state = { stage: "analyze", data: input };
    
    while (state.stage !== "complete") {
      const nextStep = await claude.ask(`
        Current stage: ${state.stage}
        Data: ${JSON.stringify(state.data)}
        
        What should we do next? (respond with stage name)
      `);
      
      state = await this[nextStep](state);
    }
    
    return state;
  }
};

This gives you intelligent routing without hardcoding every decision path.

Workflow Pattern 3: Tool Use & Function Calling

LLM workflows integrate with external tools and APIs through function calling

The real power comes when Claude can call tools. Define what Claude can do, and let it decide what to use:

const tools = [
  {
    name: "search_knowledge_base",
    description: "Search internal documentation",
    parameters: { query: "string" }
  },
  {
    name: "create_ticket",
    description: "Create support ticket in system",
    parameters: { title: "string", priority: "enum" }
  },
  {
    name: "send_email",
    description: "Send email to customer",
    parameters: { to: "string", body: "string" }
  }
];

async function automateWithTools(userRequest) {
  let response = await claude.ask(userRequest, { tools });
  
  // Claude might ask to use a tool
  while (response.type === "tool_use") {
    const result = await executeToolCall(response.toolName, response.args);
    response = await claude.continue(result);
  }
  
  return response.text;
}

Claude decides which tools to use, what arguments to pass, and when to stop. You define capabilities; it determines strategy.

Workflow Pattern 4: Error Handling & Recovery

Robust workflows anticipate failures and use Claude to decide on recovery strategies

LLM workflows fail differently. Network issues, API limits, invalid responses—you need intelligent recovery:

async function robustAutomation(input) {
  const maxRetries = 3;
  let attempt = 0;
  
  while (attempt < maxRetries) {
    try {
      // Main workflow
      const result = await executeWorkflow(input);
      return result;
      
    } catch (error) {
      attempt++;
      
      // Use Claude to decide if we should retry
      const shouldRetry = await claude.ask(`
        Automation failed with: ${error.message}
        Attempt: ${attempt} of ${maxRetries}
        
        Should we retry, or is this a permanent failure?
        Explain your reasoning.
      `);
      
      if (!shouldRetry.includes("retry")) {
        // Permanent failure—escalate
        await escalateToHuman(input, error);
        return null;
      }
      
      // Wait before retry (exponential backoff)
      await sleep(Math.pow(2, attempt) * 1000);
    }
  }
}

Instead of failing silently, escalate to humans when Claude detects unrecoverable errors.

Optimization: Token Management

Optimize token usage to reduce costs and improve latency in production workflows

As workflows scale, token costs explode. Optimize:

1. Batch similar requests Don't call Claude for each item—process 10 at once:

// Bad: 100 API calls
items.forEach(item => processWithClaude(item));

// Good: 5 API calls
const batches = chunk(items, 20);
for (const batch of batches) {
  processBatchWithClaude(batch);
}

2. Use cached context If you're analyzing the same knowledge base repeatedly, cache it:

const knowledgeBase = `... 50KB of documentation ...`;

// First call: processes full docs (counted in tokens)
await claude.ask(`Using this knowledge base: ${knowledgeBase}. Answer: ${q1}`);

// Subsequent calls: reuse cache (cheaper)
await claude.ask(`Answer: ${q2}`); // Already has context

3. Specify output format precisely Vague outputs require follow-up requests. Clear format = single request:

// Bad: requires follow-up to get structured data
"Analyze this customer feedback"

// Good: get structured output immediately
"Analyze this feedback. Respond in JSON: { sentiment, topics: [], actionItems: [] }"

4. Use cheaper models for simple tasks Not everything needs Claude 3 Opus. Haiku works for classification:

if (isComplexReasoning) {
  response = await claudeOpus.ask(prompt); // $15/M in tokens
} else {
  response = await claudeHaiku.ask(prompt); // $0.80/M in tokens
}

Cost savings compound at scale. A 10-step workflow using optimal models vs. Opus everywhere: 90% cost reduction.

Workflow Pattern 5: Async Processing & Webhooks

Long-running workflows use async patterns and webhooks to avoid blocking

Some workflows take minutes. Use async patterns:

// User submits request
app.post("/analyze", async (req, res) => {
  const jobId = generateId();
  
  // Don't wait—start background job
  startBackgroundJob(jobId, req.body);
  
  // Return immediately
  res.json({ jobId, status: "processing" });
});

// Background job runs independently
async function startBackgroundJob(jobId, data) {
  const result = await complexAnalysis(data);
  
  // Call webhook when done
  await fetch(callbackUrl, {
    method: "POST",
    body: JSON.stringify({ jobId, result })
  });
}

// Client polls or receives webhook
app.get("/jobs/:id", (req, res) => {
  const job = getJobStatus(req.params.id);
  res.json(job); // { status: "completed", result: ... }
});

For long-running workflows, always use async. Users won't wait 5 minutes for a response.

Production Checklist

Use this checklist before deploying automation workflows to production

Before deploying to production:

• ☐ Test with edge cases (empty input, very long input, special characters)
• ☐ Set API rate limits and quotas
• ☐ Implement logging and monitoring
• ☐ Create dashboards for success rate, cost, latency
• ☐ Set up alerting for errors
• ☐ Plan token budget per month and optimize accordingly
• ☐ Have a manual review process for high-stakes decisions
• ☐ Test fallback behavior when API is down
• ☐ Document the workflow for your team
• ☐ Version control all prompts and configurations
• ☐ Start with small traffic, ramp up gradually

Conclusion

Monitor your LLM workflows in production to catch issues early and optimize continuously

LLM automation isn't just automating tasks—it's replacing rigid logic with intelligent reasoning. The patterns in this guide scale from scripts running once weekly to systems handling thousands of requests daily.

Start simple: input → Claude analysis → action. As complexity grows, add state management, tool use, and error recovery. Optimize tokens ruthlessly. Monitor everything.

The teams shipping LLM automation first aren't building better algorithms—they're rethinking their workflows around reasoning instead of logic. That shift unlocks capabilities that traditional automation can't match.

FAQ

Q: What's the difference between a workflow and an agent? A: Workflows are linear (steps in order). Agents are autonomous (decide their own steps). Use workflows for defined processes; agents for open-ended tasks.

Q: Should I use OpenClaw or build my own? A: OpenClaw is purpose-built for this. Building from scratch means rewriting monitoring, logging, scheduling, error handling. Use OpenClaw unless you have specific needs it doesn't meet.

Q: How do I handle sensitive data in LLM workflows? A: Never send truly sensitive data to APIs. Pseudonymize, tokenize, or hash first. For handling PII, check data residency requirements in API docs.

Q: How much does a typical workflow cost to run? A: Highly variable. A daily email summary: $0.10/month. Processing 10,000 support tickets: $200/month. Estimate with your token usage and model pricing.

Q: What if Claude gets the analysis wrong? A: Build in human review for critical decisions. Log all Claude responses. Monitor success rates continuously. Adjust prompts when accuracy dips.