Moving beyond single prompts, agentic design patterns are the architectural blueprints for building sophisticated AI systems. Think of them not as clever prompt tricks, but as structured workflows that enable a Large Language Model (LLM) to reason, plan, and execute complex, multi-step tasks. These patterns transform a simple LLM into a capable agent.

The simplest pattern is Prompt Chaining. It involves breaking down a complex task into a series of smaller, sequential steps. The output of one prompt becomes the input for the next, creating a dependency chain. This is like an assembly line: one worker completes a task, then passes the item to the next person for their specific job.

For example, to write a market analysis report, the first prompt might ask the LLM to research competitors. The second prompt would take that list of competitors and ask for their financial data. A third prompt could then use the financial data to generate a summary and comparison. Each step builds on the last, ensuring a focused and structured process.

What if the path isn't linear? A Router pattern uses an LLM to act as a switchboard. Given an input, the router decides which of several possible next steps is most appropriate. It's a form of dynamic dispatch. For instance, a customer service agent might receive a query and the router decides whether to send it to the 'Billing Questions' module, the 'Technical Support' module, or the 'General Inquiry' module.

Sometimes, tasks can be done at the same time. The Scatter-Gather pattern, a form of parallelization, breaks a task into multiple independent sub-tasks. These are 'scattered' to be processed simultaneously—either by different agents or by multiple calls to the same LLM. Once all sub-tasks are complete, the results are 'gathered' and synthesized into a final output. This is great for tasks like analyzing different sections of a long document concurrently to speed up the overall process.

The most advanced agents can improve their own work and manage others. These patterns introduce loops and hierarchies to agentic design.

The Evaluator-Optimizer loop, also known as a Critic-Revision pattern, uses one LLM instance to generate content (the 'Optimizer' or 'Executor') and another to critique it (the 'Evaluator' or 'Critic'). The critique is then fed back to the first LLM to refine the output. This cycle can repeat until the output meets a certain quality standard, mimicking the human process of drafting, reviewing, and editing.

For truly complex goals, an Orchestrator-Worker pattern is ideal. Here, a high-level 'Orchestrator' agent acts as a project manager. It deconstructs a primary goal into smaller, manageable sub-tasks and delegates them to specialized 'Worker' agents. For example, an orchestrator tasked with 'planning a vacation' might delegate 'find flights' to a travel agent, 'book hotel' to a booking agent, and 'create itinerary' to a planning agent. The orchestrator then coordinates their results to fulfill the main goal.

To make an agent's reasoning process more transparent and robust, we can use the ReAct framework. ReAct stands for "Reason + Act." In this pattern, the LLM is prompted to explicitly verbalize its thought process before choosing an action. It alternates between generating a thought (a reasoning step) and an action (a step to take, like using a tool or querying an API). After executing the action, it gets an observation (the result of the action) and loops, using that observation to inform its next thought and action. This cycle continues until the task is complete.

This creates a clear, auditable trail of how the agent arrived at its conclusion.

By combining these patterns, you can design powerful AI agents capable of tackling sophisticated challenges far beyond the scope of a single prompt.