Design patterns

For complex tasks, planning before acting often works better than interleaved reasoning.

The agent reviews and improves its own output before presenting it.

"""
Reflection Pattern Implementation
==================================
Agent reviews and improves its output.
"""


def generate_with_reflection(
    query: str,
    generator_fn,
    critic_fn,
    max_iterations: int = 3
) -> str:
    """
    Generate content with self-reflection loop.
    
    Args:
        query: The user's request
        generator_fn: Function that generates initial content
        critic_fn: Function that critiques and suggests improvements
        max_iterations: Maximum improvement iterations
        
    Returns:
        Final improved content
    """
    # Generate initial response
    content = generator_fn(query)
    
    for i in range(max_iterations):
        # Get critique
        critique = critic_fn(
            query=query,
            content=content
        )
        
        # Check if good enough
        if critique.get("is_satisfactory", False):
            break
        
        # Improve based on feedback
        improvements = critique.get("suggestions", [])
        content = generator_fn(
            f"{query}\n\n"
            f"Previous attempt: {content}\n\n"
            f"Improvements needed: {improvements}\n\n"
            f"Please provide an improved version."
        )
    
    return content

Human-in-the-Loop

Not every decision should be automated. The Human-in-the-Loop pattern inserts approval checkpoints at critical moments. The agent does the research and drafts a recommendation. A human reviews and approves before the action executes. This is essential for high-stakes workflows like financial transactions, medical decisions, or public communications.

Swarm

The Swarm pattern uses lightweight agents that hand off tasks to each other dynamically. Instead of a central supervisor routing work, agents directly transfer control when they recognise that another agent is better suited for the current sub-task. OpenAI's Agents SDK popularised this pattern with its "handoffs" primitive.

Andrew Ng's four agent design patterns

Andrew Ng, through DeepLearning.AI, identified four foundational patterns for agentic AI that align with what we have covered.

1. Reflection. The agent reviews its own output and improves it before presenting a final answer.

2. Tool use. The agent calls external tools to ground its reasoning in real data.

3. Planning. The agent breaks complex tasks into sub-steps before executing.

4. Multi-agent collaboration. Multiple specialised agents work together, each handling a different aspect of the problem.

These are not competing patterns. Production systems typically combine several of them.