![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/prompt-chaining.png\")
AI agents. Agentic AI. Agentic architectures. Agentic workflows. Agentic patterns. Agents are everywhere. But what exactly are they, and how do we build robust and effective agentic systems? While the term "agent" is used broadly, a key characteristic is their ability to dynamically plan and execute tasks, often leveraging external tools and memory to achieve complex goals.
\nThis post aims to explore common design patterns. Think of these patterns as blueprints or reusable templates for building AI applications. Understanding them provides a mental model for tackling complex problems and designing systems that are scalable, modular, and adaptable.
\nWe'll dive into several common patterns, differentiating between more structured workflows and more dynamic agentic patterns. Workflows typically follow predefined paths, while agents have more autonomy in deciding their course of action.
\nWhy Do (Agentic) Patterns Matter?
\nWhen (and When Not) to Use Agents?
\nBefore diving into patterns, it's crucial to consider when an agentic approach is truly necessary.
\nBelow, we'll explore 3 common workflow patterns and 4 agentic patterns. We'll illustrate each using pure API calls, without relying on specific frameworks like LangChain, LangGraph, LlamaIndex, or CrewAI, to focus on the core concepts.
\nWe will cover the following patterns:
\n
The output of one LLM call sequentially feeds into the input of the next LLM call. This pattern decomposes a task into a fixed sequence of steps. Each step is handled by an LLM call that processes the output from the preceding one. It's suitable for tasks that can be cleanly broken down into predictable, sequential subtasks.
\nUse Cases:
\nPython
\n\n\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\n = \n \n# --- Step 1: Summarize Text ---\n = \n = f\n \n# Use client.models.generate_content\n = \n = \n\n \n# --- Step 2: Translate the Summary ---\n = f\n \n# Use client.models.generate_content\n = \n = \n\n \n![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/routing-or-handoff.png\")
An initial LLM acts as a router, classifying the user's input and directing it to the most appropriate specialized task or LLM. This pattern implements a separation of concerns and allows for optimizing individual downstream tasks (using specialized prompts, different models, or specific tools) in isolation. It improves efficiency and potentially reduces costs by using smaller models for simpler tasks. When a task is routed, the selected agent "takes over" responsibility for completion.
\nUse Cases:
\nPython
\n\n\n\n\n\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\n = \n \n# Define Routing Schema\n\n = \n = \n = \n \n\n : \n : \n \n# Step 1: Route the Query\n = \n# user_query = "Explain quantum physics simply."\n# user_query = "What is the capital of France?"\n \n = f\n \n# Use client.models.generate_content with config for structured output\n = \n\n \n# Step 2: Handoff based on Routing\n = \n\n = f\n = \n = \n == :\n = \n = \n\n = \n = \n\n \n![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/parallelization.png\")
A task is broken down into independent subtasks that are processed simultaneously by multiple LLMs, with their outputs being aggregated. This pattern uses concurrency for tasks. The initial query (or parts of it) is sent to multiple LLMs in parallel with individual prompts/goals. Once all branches are complete, their individual results are collected and passed to a final aggregator LLM, which synthesizes them into the final response. This can improve latency if subtasks don't depend on each other, or enhance quality through techniques like majority voting or generating diverse options.
\nUse Cases:
\nPython
\n\n\n\n\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\n = \n \n\n = await \n return \n \n\n # Define Parallel Tasks\n = \n = \n # Run tasks concurrently and gather results\n = \n = \n = await \n = \n \n \n \n \n \n \n # Aggregate results and generate final story\n = \n = f\n = await \n return \n \n \n = await \n\n![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/reflection.png\")
An agent evaluates its own output and uses that feedback to refine its response iteratively. This pattern is also known as Evaluator-Optimizer and uses a self-correction loop. An initial LLM generates a response or completes a task. A second LLM step (or even the same LLM with a different prompt) then acts as a reflector or evaluator, critiquing the initial output against the requirements or desired quality. This critique (feedback) is then fed back, prompting the LLM to produce a refined output. This cycle can repeat until the evaluator confirms the requirements are met or a satisfing output is achieved.
\nUse Cases:
\nPython
\n\n\n\n\n\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\n = \n \n\n = \n = \n \n\n : \n : \n : \n \n# --- Initial Generation Function ---\n\n = f\n \n += f\n \n = \n = \n \n return \n \n# --- Evaluation Function ---\n\n \n = f\n = \n = \n \n \n return \n \n# Reflection Loop \n = 3\n = 0\n = \n \n# simulated poem which will not pass the evaluation\n = \n \n\n += 1\n \n = \n \n \n \n \n break\n \n = \n \n \n \n \n![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/tool-use.png\")
LLM has the ability to invoke external functions or APIs to interact with the outside world, retrieve information, or perform actions. This pattern often referred to as Function Calling and is the most widely recognized pattern. The LLM is provided with definitions (name, description, input schema) of available tools (functions, APIs, databases, etc.). Based on the user query, the LLM can decide to call one or more tools by generating a structured output (like JSON) matching the required schema. This output is used to execute the actual external tool/function, and the result is returned to the LLM. The LLM then uses this result to formulate its final response to the user. This vastly extends the LLM's capabilities beyond its training data.
\nUse Cases:
\nPython
\n\n\n\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\n = \n \n# Define the function declaration for the model\n = \n \n# Placeholder function to simulate API call\n\n return \n \n# Create the config object as shown in the user's example\n# Use client.models.generate_content with model, contents, and config\n = \n = \n = \n \n# Process the Response (Check for Function Call)\n = ..\n\n = \n \n \n \n # Execute the Function\n \n # Call the actual function\n = \n # Append function call and result of the function execution to contents\n = \n # Generate final response\n = \n \n \n \n\n \n \n![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/planning.png\")
A central planner LLM breaks down a complex task into a dynamic list of subtasks, which are then delegated to specialized worker agents (often using Tool Use) for execution. This pattern tries to solve complex problems requiring multi-step reasoning by creating an intial Plan. This plan is dynamically generated based on the user input. Subtasks are then assigned to "Worker" agents that execute them, potentially in parallel if dependencies allow. An "Orchestrator" or "Synthesizer" LLM collects the results from the workers, reflects on whether the overall goal has been achieved, and either synthesizes the final output or potentially initiates a re-planning step if necessary. This reduces the cognitive load on any single LLM call, improves reasoning quality, minimizes errors, and allows for dynamic adaptation of the workflow. The key difference from Routing is that the Planner generates a multi-step plan rather than selecting a single next step.
\nUse Cases:
\nPython
\n \n\n\n\n\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\n = \n \n# Define the Plan Schema\n\n : \n : \n : = \n \n\n : \n : \n \n# Step 1: Generate the Plan (Planner LLM)\n = \n \n = f\n \n\n\n \n# Use a model capable of planning and structured output\n = \n \n# Step 2: Execute the Plan (Orchestrator/Workers - Omitted for brevity) \n\n \n![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/multi-agent.png\")
![\"\"](\"https://www.philschmid.de/static/blog/agentic-pattern/multi-agent-2.png\")
Multiple distinct agents each assigned a specific role, persona, or expertise collaborate to achieve a common goal. This pattern uses autonomous or semi-autonomous agents. Each agent might have a unique role (e.g., Project Manager, Coder, Tester, Critic), specialized knowledge, or access to specific tools. They interact and collaborate, often coordinated by a central "coordinator" or "manager" agent (like the PM in the diagram) or using handoff logic, where one agent passes the control to another agent.
\nUse Cases:
\nNote: The example below a simplified example on how to use the Multi-Agent pattern with handoff logic and structured output. I recommend to take a look at LangGraph Multi-Agent Swarm or Crew AI
\nPython
\n\n\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\n = \n \n# Define Structured Output Schemas\n\n : = \n : = \n \n# Agent Function\n\n = \n return \n \n \n# Define System Prompts for the agents\n = \n = \n \n# Prompt to be about a restaurant\n = \n\n \n# Run the first agent (Hotel Agent) to force handoff logic\n = \n \n# simulate a user interaction to change the prompt and handoff\n\n \n = \n == :\n \n = \n \n \nIt's important to remember that these patterns aren't fixed rules but flexible building blocks. Real-world agentic systems often combine elements from multiple patterns. A Planning agent might use Tool Use, and its workers could employ Reflection. A Multi-Agent system might use Routing internally for task assignment.
\nThe key to success with any LLM application, especially complex agentic systems, is empirical evaluation. Define metrics, measure performance, identify bottlenecks or failure points, and iterate on your design. Resist to over-engineer.
\nThis overview was created with the help of deep and manual research, drawing inspiration and information from several excellent resources, including:
\nThanks for reading! If you have any questions or feedback, please let me know on Twitter or LinkedIn.
\n", "content_markdown": "AI agents. Agentic AI. Agentic architectures. Agentic workflows. Agentic patterns. Agents are everywhere. But what exactly *are* they, and how do we build robust and effective agentic systems? While the term \"agent\" is used broadly, a key characteristic is their ability to dynamically plan and execute tasks, often leveraging external tools and memory to achieve complex goals.\n\nThis post aims to explore common design patterns. Think of these patterns as blueprints or reusable templates for building AI applications. Understanding them provides a mental model for tackling complex problems and designing systems that are scalable, modular, and adaptable.\n\nWe'll dive into several common patterns, differentiating between more structured **workflows** and more dynamic **agentic patterns**. Workflows typically follow predefined paths, while agents have more autonomy in deciding their course of action.\n\n**Why Do (Agentic) Patterns Matter?**\n\n- Patterns provide a structured way to think and design systems.\n- Patterns allow us to build and grow AI applications in complexity and adapt to changing requirements. Modular designs based on patterns are easier to modify and extend.\n- Patterns help manage the complexity of coordinating multiple agents, tools, and workflows by offering proven, reusable templates. They promote best practices and shared understanding among developers.\n\n**When (and When Not) to Use Agents?**\n\nBefore diving into patterns, it's crucial to consider *when* an agentic approach is truly necessary.\n\n- Always seek the simplest solution first. If you know the exact steps required to solve a problem, a fixed workflow or even a simple script might be more efficient and reliable than a agent.\n- Agentic systems often trade increased latency and computational cost for potentially better performance on complex, ambiguous, or dynamic tasks. Be sure the benefits outweigh these costs.\n- Use **workflows** for predictability and consistency when dealing with well-defined tasks where the steps are known.\n- Use **agents** when flexibility, adaptability, and model-driven decision-making are needed.\n- Keep it Simple (Still): Even when building agentic systems, strive for the simplest effective design. Overly complex agent can become difficult to debug and manage.\n- Agency introduces inherent unpredictability and potential errors. Agentic systems must incorporate robust error logging, exception handling, and retry mechanisms, allowing the system (or the underlying LLM) a chance to self-correct.\n\nBelow, we'll explore 3 common workflow patterns and 4 agentic patterns. We'll illustrate each using pure API calls, without relying on specific frameworks like LangChain, LangGraph, LlamaIndex, or CrewAI, to focus on the core concepts.\n\n## Pattern Overview\n\nWe will cover the following patterns:\n\n- [Pattern Overview](https://www.philschmid.de/agentic-pattern#pattern-overview)\n- [Workflow: Prompt Chaining](https://www.philschmid.de/agentic-pattern#workflow-prompt-chaining)\n- [Workflow: Routing or Handoff](https://www.philschmid.de/agentic-pattern#workflow-routing-or-handoff)\n- [Workflow: Parallelization](https://www.philschmid.de/agentic-pattern#workflow-parallelization)\n- [Reflection Pattern](https://www.philschmid.de/agentic-pattern#reflection-pattern)\n- [Tool Use Pattern](https://www.philschmid.de/agentic-pattern#tool-use-pattern)\n- [Planning Pattern (Orchestrator-Workers)](https://www.philschmid.de/agentic-pattern#planning-pattern-orchestrator-workers)\n- [Multi-Agent Pattern](https://www.philschmid.de/agentic-pattern#multi-agent-pattern)\n\n## Workflow: Prompt Chaining\n\n\n\nThe output of one LLM call sequentially feeds into the input of the next LLM call. This pattern decomposes a task into a fixed sequence of steps. Each step is handled by an LLM call that processes the output from the preceding one. It's suitable for tasks that can be cleanly broken down into predictable, sequential subtasks.\n\nUse Cases:\n\n- Generating a structured document: LLM 1 creates an outline, LLM 2 validates the outline against criteria, LLM 3 writes the content based on the validated outline.\n- Multi-step data processing: Extracting information, transforming it, and then summarizing it.\n- Generating newsletters based on curated inputs.\n\nPython\n\n```python\nimport os\nfrom google import genai\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\nclient = genai.Client(api_key=os.environ[\"GEMINI_API_KEY\"])\n \n# --- Step 1: Summarize Text ---\noriginal_text = \"Large language models are powerful AI systems trained on vast amounts of text data. They can generate human-like text, translate languages, write different kinds of creative content, and answer your questions in an informative way.\"\nprompt1 = f\"Summarize the following text in one sentence: {original_text}\"\n \n# Use client.models.generate_content\nresponse1 = client.models.generate_content(\n model='gemini-2.0-flash',\n contents=prompt1\n)\nsummary = response1.text.strip()\nprint(f\"Summary: {summary}\")\n \n# --- Step 2: Translate the Summary ---\nprompt2 = f\"Translate the following summary into French, only return the translation, no other text: {summary}\"\n \n# Use client.models.generate_content\nresponse2 = client.models.generate_content(\n model='gemini-2.0-flash',\n contents=prompt2\n)\ntranslation = response2.text.strip()\nprint(f\"Translation: {translation}\")\n \n```\n\n## Workflow: Routing\n\n\n\nAn initial LLM acts as a router, classifying the user's input and directing it to the most appropriate specialized task or LLM. This pattern implements a separation of concerns and allows for optimizing individual downstream tasks (using specialized prompts, different models, or specific tools) in isolation. It improves efficiency and potentially reduces costs by using smaller models for simpler tasks. When a task is routed, the selected agent \"takes over\" responsibility for completion.\n\nUse Cases:\n\n- Customer support systems: Routing queries to agents specialized in billing, technical support, or product information.\n- Tiered LLM usage: Routing simple queries to faster, cheaper models (like Llama 3.1 8B) and complex or unusual questions to more capable models (like Gemini 1.5 Pro).\n- Content generation: Routing requests for blog posts, social media updates, or ad copy to different specialized prompts/models.\n\nPython\n\n```python\nimport os\nimport json\nfrom google import genai\nfrom pydantic import BaseModel\nimport enum\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\nclient = genai.Client(api_key=os.environ[\"GEMINI_API_KEY\"])\n \n# Define Routing Schema\nclass Category(enum.Enum):\n WEATHER = \"weather\"\n SCIENCE = \"science\"\n UNKNOWN = \"unknown\"\n \nclass RoutingDecision(BaseModel):\n category: Category\n reasoning: str\n \n# Step 1: Route the Query\nuser_query = \"What's the weather like in Paris?\"\n# user_query = \"Explain quantum physics simply.\"\n# user_query = \"What is the capital of France?\"\n \nprompt_router = f\"\"\"\nAnalyze the user query below and determine its category.\nCategories:\n- weather: For questions about weather conditions.\n- science: For questions about science.\n- unknown: If the category is unclear.\n \nQuery: {user_query}\n\"\"\"\n \n# Use client.models.generate_content with config for structured output\nresponse_router = client.models.generate_content(\n model= 'gemini-2.0-flash-lite',\n contents=prompt_router,\n config={\n 'response_mime_type': 'application/json',\n 'response_schema': RoutingDecision,\n },\n)\nprint(f\"Routing Decision: Category={response_router.parsed.category}, Reasoning={response_router.parsed.reasoning}\")\n \n# Step 2: Handoff based on Routing\nfinal_response = \"\"\nif response_router.parsed.category == Category.WEATHER:\n weather_prompt = f\"Provide a brief weather forecast for the location mentioned in: '{user_query}'\"\n weather_response = client.models.generate_content(\n model='gemini-2.0-flash',\n contents=weather_prompt\n )\n final_response = weather_response.text\nelif response_router.parsed.category == Category.SCIENCE:\n science_response = client.models.generate_content(\n model=\"gemini-2.5-flash-preview-04-17\",\n contents=user_query\n )\n final_response = science_response.text\nelse:\n unknown_response = client.models.generate_content(\n model=\"gemini-2.0-flash-lite\",\n contents=f\"The user query is: {prompt_router}, but could not be answered. Here is the reasoning: {response_router.parsed.reasoning}. Write a helpful response to the user for him to try again.\"\n )\n final_response = unknown_response.text\nprint(f\"\\nFinal Response: {final_response}\")\n \n```\n\n## Workflow: Parallelization\n\n\n\nA task is broken down into independent subtasks that are processed simultaneously by multiple LLMs, with their outputs being aggregated. This pattern uses concurrency for tasks. The initial query (or parts of it) is sent to multiple LLMs in parallel with individual prompts/goals. Once all branches are complete, their individual results are collected and passed to a final aggregator LLM, which synthesizes them into the final response. This can improve latency if subtasks don't depend on each other, or enhance quality through techniques like majority voting or generating diverse options.\n\nUse Cases:\n\n- RAG with query decomposition: Breaking a complex query into sub-queries, running retrievals for each in parallel, and synthesizing the results.\n- Analyzing large documents: Dividing the document into sections, summarizing each section in parallel, and then combining the summaries.\n- Generating multiple perspectives: Asking multiple LLMs the same question with different persona prompts and aggregating their responses.\n- Map-reduce style operations on data.\n\nPython\n\n```python\nimport os\nimport asyncio\nimport time\nfrom google import genai\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\nclient = genai.Client(api_key=os.environ[\"GEMINI_API_KEY\"])\n \nasync def generate_content(prompt: str) -> str:\n response = await client.aio.models.generate_content(\n model=\"gemini-2.0-flash\",\n contents=prompt\n )\n return response.text.strip()\n \nasync def parallel_tasks():\n # Define Parallel Tasks\n topic = \"a friendly robot exploring a jungle\"\n prompts = [\n f\"Write a short, adventurous story idea about {topic}.\",\n f\"Write a short, funny story idea about {topic}.\",\n f\"Write a short, mysterious story idea about {topic}.\"\n ]\n # Run tasks concurrently and gather results\n start_time = time.time()\n tasks = [generate_content(prompt) for prompt in prompts]\n results = await asyncio.gather(*tasks)\n end_time = time.time()\n print(f\"Time taken: {end_time - start_time} seconds\")\n \n print(\"\\n--- Individual Results ---\")\n for i, result in enumerate(results):\n print(f\"Result {i+1}: {result}\\n\")\n \n # Aggregate results and generate final story\n story_ideas = '\\n'.join([f\"Idea {i+1}: {result}\" for i, result in enumerate(results)])\n aggregation_prompt = f\"Combine the following three story ideas into a single, cohesive summary paragraph:{story_ideas}\"\n aggregation_response = await client.aio.models.generate_content(\n model=\"gemini-2.5-flash-preview-04-17\",\n contents=aggregation_prompt\n )\n return aggregation_response.text\n \n \nresult = await parallel_tasks()\nprint(f\"\\n--- Aggregated Summary ---\\n{result}\")\n```\n\n## Reflection Pattern\n\n\n\nAn agent evaluates its own output and uses that feedback to refine its response iteratively. This pattern is also known as Evaluator-Optimizer and uses a self-correction loop. An initial LLM generates a response or completes a task. A second LLM step (or even the same LLM with a different prompt) then acts as a reflector or evaluator, critiquing the initial output against the requirements or desired quality. This critique (feedback) is then fed back, prompting the LLM to produce a refined output. This cycle can repeat until the evaluator confirms the requirements are met or a satisfing output is achieved.\n\nUse Cases:\n\n- Code generation: Writing code, executing it, using error messages or test results as feedback to fix bugs.\n- Writing and refinement: Generating a draft, reflecting on its clarity and tone, and then revising it.\n- Complex problem solving: Generating a plan, evaluating its feasibility, and refining it based on the evaluation.\n- Information retrieval: Searching for information and using an evaluator LLM to check if all required details were found before presenting the answer.\n\nPython\n\n```python\nimport os\nimport json\nfrom google import genai\nfrom pydantic import BaseModel\nimport enum\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\nclient = genai.Client(api_key=os.environ[\"GEMINI_API_KEY\"])\n \nclass EvaluationStatus(enum.Enum):\n PASS = \"PASS\"\n FAIL = \"FAIL\"\n \nclass Evaluation(BaseModel):\n evaluation: EvaluationStatus\n feedback: str\n reasoning: str\n \n# --- Initial Generation Function ---\ndef generate_poem(topic: str, feedback: str = None) -> str:\n prompt = f\"Write a short, four-line poem about {topic}.\"\n if feedback:\n prompt += f\"\\nIncorporate this feedback: {feedback}\"\n \n response = client.models.generate_content(\n model='gemini-2.0-flash',\n contents=prompt\n )\n poem = response.text.strip()\n print(f\"Generated Poem:\\n{poem}\")\n return poem\n \n# --- Evaluation Function ---\ndef evaluate(poem: str) -> Evaluation:\n print(\"\\n--- Evaluating Poem ---\")\n prompt_critique = f\"\"\"Critique the following poem. Does it rhyme well? Is it exactly four lines? \nIs it creative? Respond with PASS or FAIL and provide feedback.\n \nPoem:\n{poem}\n\"\"\"\n response_critique = client.models.generate_content(\n model='gemini-2.0-flash',\n contents=prompt_critique,\n config={\n 'response_mime_type': 'application/json',\n 'response_schema': Evaluation,\n },\n )\n critique = response_critique.parsed\n print(f\"Evaluation Status: {critique.evaluation}\")\n print(f\"Evaluation Feedback: {critique.feedback}\")\n return critique\n \n# Reflection Loop \nmax_iterations = 3\ncurrent_iteration = 0\ntopic = \"a robot learning to paint\"\n \n# simulated poem which will not pass the evaluation\ncurrent_poem = \"With circuits humming, cold and bright,\\nA metal hand now holds a brush\"\n \nwhile current_iteration < max_iterations:\n current_iteration += 1\n print(f\"\\n--- Iteration {current_iteration} ---\")\n evaluation_result = evaluate(current_poem)\n \n if evaluation_result.evaluation == EvaluationStatus.PASS:\n print(\"\\nFinal Poem:\")\n print(current_poem)\n break\n else:\n current_poem = generate_poem(topic, feedback=evaluation_result.feedback)\n if current_iteration == max_iterations:\n print(\"\\nMax iterations reached. Last attempt:\")\n print(current_poem)\n \n```\n\n## Tool Use Pattern\n\n\n\nLLM has the ability to invoke external functions or APIs to interact with the outside world, retrieve information, or perform actions. This pattern often referred to as Function Calling and is the most widely recognized pattern. The LLM is provided with definitions (name, description, input schema) of available tools (functions, APIs, databases, etc.). Based on the user query, the LLM can decide to call one or more tools by generating a structured output (like JSON) matching the required schema. This output is used to execute the actual external tool/function, and the result is returned to the LLM. The LLM then uses this result to formulate its final response to the user. This vastly extends the LLM's capabilities beyond its training data.\n\nUse Cases:\n\n- Booking appointments using a calendar API.\n- Retrieving real-time stock prices via a financial API.\n- Searching a vector database for relevant documents (RAG).\n- Controlling smart home devices.\n- Executing code snippets.\n\nPython\n\n```python\nimport os\nfrom google import genai\nfrom google.genai import types\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\nclient = genai.Client(api_key=os.environ[\"GEMINI_API_KEY\"])\n \n# Define the function declaration for the model\nweather_function = {\n \"name\": \"get_current_temperature\",\n \"description\": \"Gets the current temperature for a given location.\",\n \"parameters\": {\n \"type\": \"object\",\n \"properties\": {\n \"location\": {\n \"type\": \"string\",\n \"description\": \"The city name, e.g. San Francisco\",\n },\n },\n \"required\": [\"location\"],\n },\n}\n \n# Placeholder function to simulate API call\ndef get_current_temperature(location: str) -> dict:\n return {\"temperature\": \"15\", \"unit\": \"Celsius\"}\n \n# Create the config object as shown in the user's example\n# Use client.models.generate_content with model, contents, and config\ntools = types.Tool(function_declarations=[weather_function])\ncontents = [\"What's the temperature in London right now?\"]\nresponse = client.models.generate_content(\n model='gemini-2.0-flash',\n contents=contents,\n config = types.GenerateContentConfig(tools=[tools])\n)\n \n# Process the Response (Check for Function Call)\nresponse_part = response.candidates[0].content.parts[0]\nif response_part.function_call:\n function_call = response_part.function_call\n print(f\"Function to call: {function_call.name}\")\n print(f\"Arguments: {dict(function_call.args)}\")\n \n # Execute the Function\n if function_call.name == \"get_current_temperature\": \n # Call the actual function\n api_result = get_current_temperature(*function_call.args)\n # Append function call and result of the function execution to contents\n follow_up_contents = [\n types.Part(function_call=function_call),\n types.Part.from_function_response(\n name=\"get_current_temperature\",\n response=api_result\n )\n ]\n # Generate final response\n response_final = client.models.generate_content(\n model=\"gemini-2.0-flash\",\n contents=contents + follow_up_contents,\n config=types.GenerateContentConfig(tools=[tools])\n )\n print(response_final.text)\n else:\n print(f\"Error: Unknown function call requested: {function_call.name}\")\nelse:\n print(\"No function call found in the response.\")\n print(response.text)\n```\n\n## Planning Pattern (Orchestrator-Workers)\n\n\n\nA central planner LLM breaks down a complex task into a dynamic list of subtasks, which are then delegated to specialized worker agents (often using Tool Use) for execution. This pattern tries to solve complex problems requiring multi-step reasoning by creating an intial Plan. This plan is dynamically generated based on the user input. Subtasks are then assigned to \"Worker\" agents that execute them, potentially in parallel if dependencies allow. An \"Orchestrator\" or \"Synthesizer\" LLM collects the results from the workers, reflects on whether the overall goal has been achieved, and either synthesizes the final output or potentially initiates a re-planning step if necessary. This reduces the cognitive load on any single LLM call, improves reasoning quality, minimizes errors, and allows for dynamic adaptation of the workflow. The key difference from Routing is that the Planner generates a *multi-step plan* rather than selecting a single next step.\n\nUse Cases:\n\n- Complex software development tasks: Breaking down \"build a feature\" into planning, coding, testing, and documentation subtasks.\n- Research and report generation: Planning steps like literature search, data extraction, analysis, and report writing.\n- Multi-modal tasks: Planning steps involving image generation, text analysis, and data integration.\n- Executing complex user requests like \"Plan a 3-day trip to Paris, book flights and a hotel within my budget.\"\n\nPython\n\n```python\n \nimport os\nfrom google import genai\nfrom pydantic import BaseModel, Field\nfrom typing import List\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\nclient = genai.Client(api_key=os.environ[\"GEMINI_API_KEY\"])\n \n# Define the Plan Schema\nclass Task(BaseModel):\n task_id: int\n description: str\n assigned_to: str = Field(description=\"Which worker type should handle this? E.g., Researcher, Writer, Coder\")\n \nclass Plan(BaseModel):\n goal: str\n steps: List[Task]\n \n# Step 1: Generate the Plan (Planner LLM)\nuser_goal = \"Write a short blog post about the benefits of AI agents.\"\n \nprompt_planner = f\"\"\"\nCreate a step-by-step plan to achieve the following goal. \nAssign each step to a hypothetical worker type (Researcher, Writer).\n \nGoal: {user_goal}\n\"\"\"\n \nprint(f\"Goal: {user_goal}\")\nprint(\"Generating plan...\")\n \n# Use a model capable of planning and structured output\nresponse_plan = client.models.generate_content(\n model='gemini-2.5-pro-preview-03-25',\n contents=prompt_planner,\n config={\n 'response_mime_type': 'application/json',\n 'response_schema': Plan,\n },\n)\n \n# Step 2: Execute the Plan (Orchestrator/Workers - Omitted for brevity) \nfor step in response_plan.parsed.steps:\n print(f\"Step {step.task_id}: {step.description} (Assignee: {step.assigned_to})\")\n```\n\n## Multi-Agent Pattern\n\n *Coordinator, Manager approach*  *Swarm approach*\n\nMultiple distinct agents each assigned a specific role, persona, or expertise collaborate to achieve a common goal. This pattern uses autonomous or semi-autonomous agents. Each agent might have a unique role (e.g., Project Manager, Coder, Tester, Critic), specialized knowledge, or access to specific tools. They interact and collaborate, often coordinated by a central \"coordinator\" or \"manager\" agent (like the PM in the diagram) or using handoff logic, where one agent passes the control to another agent.\n\nUse Cases:\n\n- Simulating debates or brainstorming sessions with different AI personas.\n- Complex software creation involving agents for planning, coding, testing, and deployment.\n- Running virtual experiments or simulations with agents representing different actors.\n- Collaborative writing or content creation processes.\n\nNote: The example below a simplified example on how to use the Multi-Agent pattern with handoff logic and structured output. I recommend to take a look at [LangGraph Multi-Agent Swarm](https://github.com/langchain-ai/langgraph-swarm-py) or [Crew AI](https://www.crewai.com/open-source)\n\nPython\n\n```python\nfrom google import genai\nfrom pydantic import BaseModel, Field\n \n# Configure the client (ensure GEMINI_API_KEY is set in your environment)\nclient = genai.Client(api_key=os.environ[\"GEMINI_API_KEY\"])\n \n# Define Structured Output Schemas\nclass Response(BaseModel):\n handoff: str = Field(default=\"\", description=\"The name/role of the agent to hand off to. Available agents: 'Restaurant Agent', 'Hotel Agent'\")\n message: str = Field(description=\"The response message to the user or context for the next agent\")\n \n# Agent Function\ndef run_agent(agent_name: str, system_prompt: str, prompt: str) -> Response:\n response = client.models.generate_content(\n model='gemini-2.0-flash',\n contents=prompt,\n config = {'system_instruction': f'You are {agent_name}. {system_prompt}', 'response_mime_type': 'application/json', 'response_schema': Response}\n )\n return response.parsed\n \n \n# Define System Prompts for the agents\nhotel_system_prompt = \"You are a Hotel Booking Agent. You ONLY handle hotel bookings. If the user asks about restaurants, flights, or anything else, respond with a short handoff message containing the original request and set the 'handoff' field to 'Restaurant Agent'. Otherwise, handle the hotel request and leave 'handoff' empty.\"\nrestaurant_system_prompt = \"You are a Restaurant Booking Agent. You handle restaurant recommendations and bookings based on the user's request provided in the prompt.\"\n \n# Prompt to be about a restaurant\ninitial_prompt = \"Can you book me a table at an Italian restaurant for 2 people tonight?\"\nprint(f\"Initial User Request: {initial_prompt}\")\n \n# Run the first agent (Hotel Agent) to force handoff logic\noutput = run_agent(\"Hotel Agent\", hotel_system_prompt, initial_prompt)\n \n# simulate a user interaction to change the prompt and handoff\nif output.handoff == \"Restaurant Agent\":\n print(\"Handoff Triggered: Hotel to Restaurant\")\n output = run_agent(\"Restaurant Agent\", restaurant_system_prompt, initial_prompt)\nelif output.handoff == \"Hotel Agent\":\n print(\"Handoff Triggered: Restaurant to Hotel\")\n output = run_agent(\"Hotel Agent\", hotel_system_prompt, initial_prompt)\n \nprint(output.message) \n```\n\n## Combining and Customizing These Patterns\n\nIt's important to remember that these patterns aren't fixed rules but flexible building blocks. Real-world agentic systems often combine elements from multiple patterns. A Planning agent might use Tool Use, and its workers could employ Reflection. A Multi-Agent system might use Routing internally for task assignment.\n\nThe key to success with any LLM application, especially complex agentic systems, is empirical evaluation. Define metrics, measure performance, identify bottlenecks or failure points, and iterate on your design. Resist to over-engineer.\n\n## Acknowledgements\n\nThis overview was created with the help of deep and manual research, drawing inspiration and information from several excellent resources, including:\n\n- [5 Agentic AI Design Patterns](https://blog.dailydoseofds.com/p/5-agentic-ai-design-patterns)\n- [What are Agentic Workflows?](https://weaviate.io/blog/what-are-agentic-workflows)\n- [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)\n- [How Agents Can Improve LLM Performance](https://www.deeplearning.ai/the-batch/how-agents-can-improve-llm-performance)\n- [Agentic Design Patterns](https://medium.com/@bijit211987/agentic-design-patterns-cbd0aae2962f)\n- [Agent Recipes](https://www.agentrecipes.com/)\n- [LangGraph Agentic Concepts](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/)\n- [OpenAI Agents Python Examples](https://github.com/openai/openai-agents-python/tree/main/examples/agent_patterns)\n- [Anthropic Cookbook](https://github.com/anthropics/anthropic-cookbook/blob/main/patterns/agents)\n\n* * *\n\nThanks for reading! If you have any questions or feedback, please let me know on [Twitter](https://twitter.com/_philschmid) or [LinkedIn](https://www.linkedin.com/in/philipp-schmid-a6a2bb196/).\n", "dateCreated": "2026-09-27T19:29:15.293681927+00:00", "date_created": "2025-05-05T00:00:00+00:00", "date_modified": "2025-05-05T00:00:00+00:00", "date_published": "2025-05-05T00:00:00+00:00", "description": "Learn common agentic design patterns and workflows for building robust, scalable AI applications, understanding when to use each.", "external_url": "https://www.philschmid.de/agentic-pattern", "git": { "commit": "ebb0941c5c06a2ab2377342d607535262a3e969e", "path": "items/philschmid-de/2025/05/2025-05-05-zero-to-one-learning-agentic-patterns.md", "permalink": "https://github.com/aymericbeaumet/aggr-instance/blob/ebb0941c5c06a2ab2377342d607535262a3e969e/items/philschmid-de/2025/05/2025-05-05-zero-to-one-learning-agentic-patterns.md" }, "id": "urn:aggr:item:930760864d4f668be93e5b0612270b77e8d946ce", "isBasedOn": { "@id": "https://www.philschmid.de/agentic-pattern" }, "mainEntity": { "@id": "https://www.philschmid.de/agentic-pattern", "@type": "CreativeWork", "archivedAt": { "@id": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-05-05-zero-to-one-learning-agentic-patterns/#webpage" }, "dateModified": "2025-05-05T00:00:00+00:00", "datePublished": "2025-05-05T00:00:00+00:00", "headline": "Zero to One: Learning Agentic Patterns", "timeRequired": "PT14M", "url": "https://www.philschmid.de/agentic-pattern", "wordCount": 3119 }, "name": "Archived snapshot: Zero to One: Learning Agentic Patterns", "preview": null, "reading_minutes": 14, "replicated_at": null, "source": "philschmid-de", "source_name": "philschmid.de - RSS feed", "summary": "Learn common agentic design patterns and workflows for building robust, scalable AI applications, understanding when to use each.", "tags": [], "temporalCoverage": "2026-09-27T19:29:15.293681927+00:00", "title": "Zero to One: Learning Agentic Patterns", "url": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-05-05-zero-to-one-learning-agentic-patterns/", "word_count": 3119 }