Analytics Anecdotes

Design Patterns in Agentic AI

Medha Khurana

29 Jun 2025 • 8 min read

In my last blog, I introduced the different components of Agentic AI. These components help answer the “what”.

What enables an agent to take independent action, and
What allows it to remember and learn from past interactions?

But there’s a crucial follow-up question we haven’t tackled yet.

How do these components come together, and how are they arranged to enable truly autonomous behaviour?

That’s exactly what we’ll cover in this blog.

Quick Recap: Agentic AI Core Components

Before diving into the Design Patterns, here’s a quick refresher of the Agentic AI Components covered in the last blog:

Goal - The user's prompt or task. This defines what the agent is trying to achieve.
Orchestrator - The team lead who ensures everything runs in sync and on schedule.
Planner - The project manager who breaks the goal into sub-tasks and prioritises them.
Executor - The analyst who carries out the tasks.
Tools - The various applications the executor uses to get the work done.
LLM (Large Language Model) - The brain of the system, enabling decision-making and action.
Memory - The agent’s ability to remember previous steps, results, and context.

Each of these is a capability. But simply having capabilities isn’t enough.
It’s how these components are used, in what sequence, and with what logic.
That’s where Design Patterns come into play.

What are Design Patterns in Agent AI?

Design patterns are about how to design your Agentic AI system - specifically, which architecture to follow so that the agent can perform tasks, make decisions, and interact with other systems in a more autonomous and human-like manner.

They give the brain of the agent, the LLM, critical powers:

The ability to evaluate its own results
The flexibility to choose the right tool for the task at hand
And the logic to try again if needed, just like a human would

In other words, design patterns give structure to the agent’s thinking process.
They enable the system to not just “respond,” but to self-correct, adapt, and improve, turning a one-off interaction into an intelligent, ongoing workflow.

5 Types of Design Patterns

Now that we’ve covered what design patterns are and why they matter, let’s move on to the exciting part - the different types of design patterns you can use to bring your Agentic AI system to life.

Source: Image generated by author using NapkinAI

Reflection Pattern

When we use ChatGPT or any similar AI tool, we don’t always accept the first response it gives. We often give feedback, ask it to improve its tone, make the output more accurate, or fix specific details. In other words, we engage in an iterative loop to get a better result.

But in an Agentic AI system, the user isn’t always present to do that. So, how do we still ensure high-quality outputs or decisions?

We need to automate that feedback loop within the agent itself, and that’s exactly what the Reflection Pattern enables.

Source: Image created by author in PowerPoint

In the Reflection Pattern, we give the LLM the ability to review its own output against a set of pre-defined criteria. These criteria act as a checklist, guiding the LLM on what to focus on when evaluating its own response.

Example Instruction given to LLM:

You are an AI assistant summarizing a research paper. Your goal is to produce a concise and accurate summary. Reflect on your own summary, check for missing key points, logical inconsistencies, or vague phrasing. If you find issues, revise the summary and output the improved version.

We can even go beyond single-agent reflection and introduce two LLMs instead of one.

Here,

One LLM acts as the generator, producing the initial output.
The second LLM acts as the reviewer, evaluating the response against the criteria and providing feedback.

This iterative back-and-forth continues until a satisfactory result is achieved.

The reviewer LLM can also leverage external tools or knowledge bases during this process. For example, it can use a Retrieval-Augmented Generation (RAG) system to fact-check and ensure the output is grounded in accurate information.

Routing Pattern

In the Routing Pattern, the planner leverages the LLM to decide which path or workflow branch to take based on the user’s goal and the broader context.

Source: Image generated by author using ChatGPT

The LLM evaluates the nature of the request, such as whether it needs real-time information, complex reasoning, or simple text generation, and directs the workflow accordingly. It doesn’t choose tools directly; instead, it chooses the most appropriate workflow route, which may involve one or more tools or processes.

Studies on agentic systems describe this as “LLM as a router,” where the LLM identifies the correct path among predefined options before any action is taken.

Tool Use Pattern

It is the most popular design pattern used in Agentic AI. Essentially, the LLM decides both if and when to call a tool, and what parameters to pass based on the user’s goal and the current context.

The LLM analyses the prompt and its own capabilities (tool list). If a task requires more than text generation, like checking real-time data, executing calculations, or calling APIs, it opts to use a tool. For instance, it might decide to perform a web search or run a calculator function

The LLM constructs the exact inputs for the tool. Parameters like search queries, calculation inputs, API arguments are derived from the goal or historical context. The agent executes the tool call, receives the output, and integrates the results back into its reasoning process, continuing the task flow.

Example,

User: “What’s the latest stock price of XYZ Corp?”

The LLM knows this requires current data. It chooses a stock‑price lookup tool. Fills in parameter: ticker=XYZ. Calls the tool, retrieves the price, and returns:
“XYZ Corp is currently trading at £45.20.”

Planning Pattern

Not all goals can be solved with a single-step response. Many require a multi-step workflow, a sequence of tasks that build on each other to reach the final objective. That’s where the Planning Design Pattern comes in.

In this pattern, the agent uses the LLM to break down a complex goal into a set of sub-goals. These sub-goals are then translated into tasks and subtasks, which are executed in a logical, often sequential, workflow.

Each task in the plan may need its own logic to determine how it should be executed. This could involve:

Routing logic (to choose the right pathway),
Action execution (to perform a specific step),
Or tool invocation (to complete a task using external capabilities).

By mapping sub-goals to clear execution steps, the planning pattern introduces structure and modularity to an otherwise free-flowing agent. It ensures the agent doesn't just respond reactively, but proactively plans the best route forward.

Multi-Agent Pattern

As the name suggests, this pattern leverages multiple agents working together to accomplish a single goal. This is similar to how humans collaborate in teams, each person bringing their unique expertise to the table to complete a project efficiently.

In a multi-agent system, each agent is specialized in a specific domain or task. Some may focus on data retrieval, others on analysis, summarisation, or even tool execution. These agents communicate, coordinate, and delegate responsibilities among themselves to achieve the final outcome.

What makes this pattern powerful is that agents can be reused across different systems, like modular building blocks. These agents might be:

Built in-house for custom needs,
Sourced from open-source agent libraries,
Or even integrated from third-party providers.

This approach adds scalability, specialisation, and flexibility to your Agentic AI system. By allowing agents to work together, each doing what it does best, we are able to create a system that’s more robust, faster, and closer to real-world collaboration.

Closing

To bring together everything we’ve explored so far from prompting techniques to Agentic AI core components and now design patterns, the table below helps wrap it all up.

As always, thanks for reading the blog till the end. Subscribe below to never miss an update on the website.

References:

Wu, K. (2024). How Agents Can Improve LLM Performance. DeepLearning.AI – The Batch. Retrieved from https://www.deeplearning.ai/the-batch/how-agents-can-improve-llm-performance/?ref=dl-staging-website.ghost.io

Analytics Vidhya. (2024). Agentic Design Patterns: Enhancing AI Capabilities with Autonomy. Retrieved from https://www.analyticsvidhya.com/blog/2024/10/agentic-design-patterns

Patel, D. (2024). 5 Levels of Agentic AI Systems… Explained Visually. Daily Dose of DS. Retrieved from https://blog.dailydoseofds.com/p/5-levels-of-agentic-ai-systems

Yao, S., Zhao, J., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv preprint. Retrieved from https://arxiv.org/abs/2210.03629

LangChain Documentation. (2024). Agent Types & Design Patterns. Retrieved from https://docs.langchain.com

OpenAI. (2023). Introducing Function Calling and Tool Use in ChatGPT. OpenAI Blog. Retrieved from https://openai.com/blog/function-calling-and-other-api-updates

Grant, C. (2023). Building Agentic Workflows with Planning and Reflection. Prompt Engineering Guide. Retrieved from https://www.promptingguide.ai