Designing Agent Workflows for Business Processes

Converting a business process into an agent workflow:

Step 1: Document the current process - What triggers the process? - What are the steps? - What decisions are made? - What systems are involved? - How do exceptions get handled?

Step 2: Identify agent-suitable steps Not everything should be automated: - Reasoning/judgment calls → Agent - Data lookup/transformation → Agent or traditional code - Policy decisions → Human or strict rules - Creative tasks → Agent with human review

Step 3: Define states What are the possible states of a task? - Pending, In Progress, Awaiting Approval - Completed, Failed, Escalated

Step 4: Map transitions What moves the task between states? - Agent actions - Human approvals - External events - Timeouts

Every workflow has decision points where the path branches:

Types of decisions:

Agent-decidable: - Based on clear criteria the agent can evaluate - Example: "If order > $100, apply discount" - Agent has the information and authority

Human-required: - Policy decisions outside agent scope - High-stakes irreversible actions - Edge cases requiring judgment - Example: "Approve refund over $500"

Rule-based: - Deterministic logic that doesn't need LLM - Implement in code, not agent reasoning - Example: "Route to EU support if country in EU list"

Design principle: Make decisions explicit. Don't let the agent make important decisions implicitly. Define decision points clearly in the workflow.

Most production workflows need human involvement somewhere:

Where to insert humans:

Approval gates: - Before irreversible actions (sending emails, making charges) - For high-value decisions - When confidence is low

Review points: - Quality check before final output - Audit sample of automated decisions - Training data collection

Escalation paths: - Agent can't handle the case - User requests human - Error threshold exceeded

Implementation patterns:

Async approval: - Agent requests approval - Waits (or moves to other tasks) - Resumes when approved

Timed auto-approval: - Human has X time to review - Auto-approves if no intervention - Good for low-risk, high-volume

Human takeover: - Agent hands off completely - Human completes the task - Agent learns from the resolution

Agent workflows must handle failures gracefully:

Types of failures:

Tool failures: - API errors, timeouts, rate limits - Strategy: Retry with backoff, try alternative

Reasoning failures: - Agent misunderstands or goes off track - Strategy: Detect via validation, reset context

External failures: - Systems unavailable, data missing - Strategy: Graceful degradation, notify humans

Error handling patterns:

Retry with backoff: Transient failures often resolve with retry.

Checkpoint and resume: Save state so workflow can resume after fixing issues.

Fallback paths: Alternative approaches when primary fails.

Graceful degradation: Provide partial value even when full completion isn't possible.

Escalation: When recovery isn't possible, escalate to humans with full context.

You must be able to understand what your agent is doing:

What to log: - Every agent decision and reasoning - All tool calls with inputs and outputs - State transitions - Errors and recoveries - Human interventions - Timing information

Tracing structure: - Unique ID per workflow execution - Parent-child relationships for nested actions - Timestamps for performance analysis - Correlation with user sessions

Monitoring needs: - Success/failure rates by workflow type - Time to completion distributions - Cost per execution - Human intervention frequency - Error patterns and trends

Debugging capabilities: - Replay any workflow step by step - Understand why agent made each decision - Compare successful vs. failed runs - Test changes against historical inputs

Build observability from the start. Retrofitting is painful.