Error Recovery in LLM Agents (2026)

When to Use

• ✓Building any production agent that calls external APIs which can fail or timeout
• ✓Agents that generate structured outputs (JSON, code) that need validation before use
• ✓Multi-step workflows where a partial failure should produce a partial result, not a full crash
• ✓High-stakes agents (financial, legal) where silent failures are worse than explicit errors
• ✓Any agent running in an unmonitored production environment where issues need to be self-healable

How It Works

1. 1Classify errors by recovery strategy: retryable (network timeout, rate limit), fixable (wrong argument format, missing required field), and fatal (invalid credentials, user not found). Handle each class differently.
2. 2Return structured error messages as tool results, not Python tracebacks: {"error": "INVALID_PARAMETER", "field": "date", "message": "Date must be in YYYY-MM-DD format", "received": "04/16/2026"}. The model can understand and fix structured errors; it can't parse stack traces.
3. 3Allow retry with backoff: for retryable errors, retry 2-3 times with exponential backoff (1s, 4s, 16s). Tell the model about the retry: 'Previous call failed with timeout. Retrying...'
4. 4Implement a fallback path: if the primary approach fails 3 times, route to a simplified path (fewer tools, more constrained prompt) or return a partial result with a clear error message.
5. 5Add a global step counter and exit strategy: if the agent exceeds N steps without reaching a final answer, emit a structured error response with the intermediate state captured so far.

Examples

def safe_tool_executor(tool_name: str, tool_args: dict) -> dict:
    try:
        # Validate arguments before calling
        validated_args = validate_tool_args(tool_name, tool_args)
        result = tools[tool_name](**validated_args)
        return {'status': 'success', 'data': result}
    
    except ValidationError as e:
        return {
            'status': 'error',
            'error_type': 'INVALID_ARGUMENTS',
            'details': str(e),
            'hint': f'Valid arguments for {tool_name}: {get_tool_schema(tool_name)}'
        }
    except TimeoutError:
        return {
            'status': 'error',
            'error_type': 'TIMEOUT',
            'hint': 'The service is temporarily unavailable. Try a different approach or wait 30 seconds.'
        }
    except Exception as e:
        # Log the real error, return safe message
        logger.error(f'Tool {tool_name} failed: {e}', exc_info=True)
        return {
            'status': 'error',
            'error_type': 'UNKNOWN',
            'hint': 'The tool encountered an unexpected error. Consider an alternative approach.'
        }

MAX_ATTEMPTS = 3
MAX_STEPS = 15

def robust_agent(task: str, tools: list) -> dict:
    attempts = 0
    step_count = 0
    last_error = None
    
    while attempts < MAX_ATTEMPTS:
        try:
            result = run_agent_loop(
                task=task,
                tools=tools,
                max_steps=MAX_STEPS,
                prior_error=last_error
            )
            return {'status': 'success', 'result': result}
        
        except LoopDetectedError as e:
            last_error = f'Agent looped on: {e.repeated_action}. Try a different approach.'
            attempts += 1
        except MaxStepsError:
            return {'status': 'partial', 'result': e.intermediate_state, 'error': 'Task too complex'}
    
    return {
        'status': 'failed',
        'error': 'Max retries exceeded',
        'last_error': last_error,
        'escalate_to_human': True
    }

Common Mistakes

• ✗Returning empty tool results on error — an empty string or null as tool_result causes the model to hallucinate what the tool returned. Always return a descriptive error message that explicitly states what went wrong.
• ✗No loop detection — agents can enter infinite loops calling the same failing tool repeatedly. Track (tool_name, argument_hash) across steps and raise an error if the same call appears twice.
• ✗Silently swallowing errors — catching all exceptions and returning 'success' hides failures that need human attention. Log all tool failures with full context; return structured errors to the model.
• ✗Over-retrying expensive operations — retrying a $0.50 LLM call 3 times because of a transient error can get expensive in high-volume systems. Implement circuit breakers and retry only for cheap, idempotent operations.

FAQ