1.What is an Agentic AI Design Pattern?

An Agentic AI Design Pattern is a reusable architectural approach for designing AI agents that can independently reason, make decisions, use tools, perform actions, and adapt based on results to achieve a specific goal.

An Agentic AI Design Pattern is a proven way of structuring an AI agent’s reasoning, planning, memory, tool usage, decision-making, and interaction with other agents or humans.

2.Workflows design patterns are.

• Prompt Chaining
• Routing
• Parallelization
• Orchestrator-Worker
• Evaluator-optimizer

2.1. Prompt Chaining

Prompt Chaining is an agentic AI design pattern where a complex task is divided into multiple smaller steps, and the output of one LLM prompt becomes the input to the next prompt.

How Prompt Chaining Works

Consider a software-development example.

The user says: “Build a REST API for customer management.”

The agentic system can divide the work:

Step 1 — Requirement Analysis

Instead of using one large prompt, we can create a chain:

Prompt: Analyze the requirements for a Customer Management REST API. Identify entities, operations, validations and business rules.

Output:

Customer

• id
• name
• email
• phone

Operations:

• Create Customer
• Get Customer
• Update Customer
• Delete Customer

Step 2 — API Design

The output from Step 1 is passed to the next prompt.

Using the requirements below, design REST APIs for the Customer Management system.

<Output from Step 1>

Output:

POST   /customers
GET    /customers/{id}
PUT    /customers/{id}
DELETE /customers/{id}

Step 3 — Code Generation

Using the API design below, generate Spring Boot controller and service classes.

<Output from Step 2>

Step 4 — Code Review

Review the generated Spring Boot code. Identify security, performance and design issues.

<Generated Code>

Step 5 — Final Improvement

Apply the review recommendations and produce the final production-ready implementation.

<Code + Review>

Why Use Prompt Chaining?

A single prompt can become extremely complicated when a task contains many responsibilities.

For example:

Research → Analyze → Design → Generate → Validate → Optimize

Trying to perform all of these in one prompt can reduce reliability.

2.2.Routing

The Routing Design Pattern is an agentic AI pattern where a router analyzes the user’s request and dynamically decides which agent, tool, workflow, or specialized LLM should handle it.The router acts like a traffic controller for the agentic system.

Example in CRM/DMS

Since CRM/DMS is a good example of an enterprise Agentic system, imagine you have the following agents:

Suppose the customer says: “Show me my open opportunities.”

The Router identifies:

Intent = CRM
Operation = Retrieve Opportunities

So it routes the request to:

Another request

Customer: “What parts were replaced during my last service?”

Router:

Intent = DMS
Operation = Service/Parts Information

Therefore:

Another request

Customer: “My car has broken down. I need roadside assistance.”

Router:

Intent = Roadside Assistance

How Does the Router Make the Decision?

The Router can use an LLM to classify the user’s request.

For example:

The system then invokes the selected agent.

2.3. Parallelization

Parallelization is an Agentic AI design pattern in which a complex task is divided into independent subtasks that are executed concurrently, and their results are then combined to produce the final response. The main goal is to reduce execution time, improve scalability, and allow independent tasks to work at the same time.

Simple Example

Suppose you ask an AI: “Analyze a company before I invest in it.”

The system can divide the work into independent tasks:

All three agents can work in parallel.

Why Parallelization?

Imagine each task takes 10 seconds.

Sequential approach

If you execute three tasks one after another:

Task A → 10 sec
   ↓
Task B → 10 sec
   ↓
Task C → 10 sec

Total ≈ 30 seconds

Parallel approach

If they are independent:

Task A ── 10 sec ──┐
Task B ── 10 sec ──┼──→ Combine
Task C ── 10 sec ──┘

Total ≈ 10 seconds

So parallelization can significantly reduce latency.Actual time depends on infrastructure, model latency, tool calls, rate limits, and the slowest branch.

Example in CRM/DMS

Consider an automotive customer asking: “Give me a complete summary of my vehicle.”

The Agentic system could retrieve different types of information independently.

For example:

Vehicle Agent

Retrieves:

Vehicle:
Model = Hyundai Creta
Year = 2024
VIN = XXXXX

Service Agent

Retrieves:

Last Service = 15-Aug-2026
Service Type = Periodic
Parts Replaced = Oil Filter, Air Filter

Insurance Agent

Retrieves:

Insurance = Active
Expiry = 20-Dec-2026

The Aggregator combines everything:

Vehicle Details
       +
Service History
       +
Insurance
       ↓
Complete Vehicle Summary

2.4.Orchestrator-Worker

The Orchestrator–Worker Design Pattern is an Agentic AI pattern where a central Orchestrator Agent analyzes a complex task, breaks it into smaller subtasks, assigns those subtasks to specialized Worker Agents, and then combines their results into a final outcome.

2. How does it work?

Suppose the user asks:

“Analyze whether Reliance Industries is a good investment.”

This is a complex task.

The orchestrator can divide it into:

Each worker specializes in one area.

Worker 1 — Fundamental Agent

Analyzes:

• Revenue
• Profit
• EPS
• P/E
• Debt
• ROE
• Cash flow

Worker 2 — Technical Agent

Analyzes:

• Trend
• Support/resistance
• RSI
• Moving averages
• Bollinger Bands
• Volume

Worker 3 — Industry Agent

Analyzes:

• Competitors
• Industry growth
• Market position
• Industry risks

Worker 4 — Sentiment Agent

Analyzes:

• Recent news
• Market sentiment
• Management announcements

Worker 5 — Risk Agent

Analyzes:

• Business risks
• Regulatory risks
• Debt risks
• Market risks

The orchestrator then combines all these results.

3. Why do we need an Orchestrator?

Without an orchestrator, you could have several independent agents:

User
 |
 ├── Fundamental Agent
 ├── Technical Agent
 ├── Sentiment Agent
 ├── Industry Agent
 └── Risk Agent

4. Orchestrator Responsibilities

The orchestrator typically performs five major activities:

① Task decomposition

Break a large task into smaller tasks.

"Build an e-commerce application"

        ↓

Frontend
Backend
Database
Payment
Authentication
Notification
Testing
Deployment

② Task delegation

Assign each task to an appropriate worker.

Frontend → Frontend Worker

Backend → Java/Spring Worker

Database → Database Worker

Payment → Payment Worker

③ Coordination

The orchestrator tracks worker progress and dependencies.

For example:

Database Worker
      ↓
Backend Worker
      ↓
Testing Worker

The backend may need the database schema before it can complete its work.

④ Result aggregation

The orchestrator collects the results:

Worker 1 → Result A
Worker 2 → Result B
Worker 3 → Result C
Worker 4 → Result D

⑤ Final synthesis

The orchestrator combines everything into a coherent response.

A + B + C + D
      ↓
Orchestrator
      ↓
Final Solution

2.5.Evaluator-optimizer

The Evaluator–Optimizer pattern is an agentic design pattern where one AI agent generates an output, and another AI component evaluates that output and provides feedback. The generator then uses the feedback to improve the result.

Generate → Evaluate → Improve → Evaluate again → Final Output

This pattern is useful when the first answer is unlikely to be perfect and you want the system to iteratively improve quality.

1. Optimizer / Generator

The Optimizer creates or improves the output.

For example, suppose the user asks:

“Write a professional blog about Agentic AI.”

The optimizer generates the first draft:

“Agentic AI is a type of artificial intelligence that can…”

2. Evaluator

The Evaluator checks the generated output against predefined criteria.

For example:

Evaluate the blog based on:

- Technical accuracy
- SEO
- Readability
- Structure
- Examples
- Grammar

Score each category from 1–10.
Identify weaknesses and suggest improvements.

The evaluator might return:

Technical Accuracy: 9/10
SEO: 6/10
Readability: 8/10
Examples: 5/10

Problems:
1. Introduction is too generic.
2. No real-world example.
3. Missing SEO keywords.
4. Conclusion needs improvement.

3. Optimization

The optimizer receives this feedback and produces a better version:

Original Draft
      +
Evaluator Feedback
      ↓
Improved Draft

The improved draft is then evaluated again.