Agentic Design Patterns
Planner-executor, reflection loops, verification steps, and agent evals — the patterns that make agents reliable in production.
Key vocabulary
- Planner-executor pattern — one agent plans the steps, a separate agent executes them.
- Reflection loop — the agent critiques its own output and iterates to improve it.
- Verification step — a check that confirms the agent’s action had the intended effect.
- Agent evals — systematic evaluation of agent performance across a set of test cases.
- Speculative planning — generating a full plan before executing any step.
0 / 37 completed
1 / 37
The planner-executor pattern separates:
Planner-executor: the planner produces a structured plan; the executor carries it out. The plan is inspectable and correctable before execution begins.
2 / 37
A reflection loop in an agent system allows the agent to:
Reflection loop = self-critique + iteration. The agent reviews its output (“What is wrong? What is missing?”) and produces a revised version. Improves quality at the cost of more LLM calls.
3 / 37
A verification step in an agentic workflow:
Verification step: after the agent acts, it confirms the action succeeded. Example: after create_file(), call read_file() to verify the content. Without verification, agents can produce confident outputs based on silently failed actions.
4 / 37
Agent evals are used to:
Agent evals = test suites for agent behaviour. Contain: (1) input scenarios, (2) expected outcomes or grading criteria, (3) a scoring function. Often use LLM-as-judge scoring because the expected output is a range of acceptable responses.
5 / 37
When a team says “we use speculative planning before executing,” they mean:
Speculative planning: generate the complete step-by-step plan first, then execute. The plan is inspectable, prevents aimless tool calls, and gives the agent a clear commitment to work toward.
6 / 37
Reviewer: 'I'm seeing a lot of calls to the `calculate_discount()` function here. It seems like the agent is repeatedly recalculating the discount based on the same items each time. Could you consider using an agent evaluation to store and reuse this calculated value, preventing redundant computation?' What does the reviewer mean by suggesting an 'agent evaluation' in this context?
The reviewer is referring to an agent evaluation, which is a core concept in agentic design. It's not about coding style or database queries, but rather the agent's ability to *remember* and reuse computed values – like the discount – instead of recomputing them every time. This optimizes performance by reducing unnecessary processing within the agent itself.
7 / 37
PR Description:
"Implemented the new loyalty program agent. This agent calculates discounts based on user purchase history and applies them to orders. I've used a loop to iterate through all items in the cart and apply the discount."The PR description focuses solely on the implementation details without considering potential optimization. The reviewer is highlighting that using a simple loop to calculate discounts repeatedly, especially for large carts, can lead to performance bottlenecks. An 'agent evaluation' in this context would represent a mechanism to store and reuse the calculated discount value—avoiding redundant computation and improving efficiency.
incorrect options present misunderstandings of the core principle: agent evaluations are about optimizing *how* calculations are performed, not just the basic implementation.8 / 37
Reviewer: 'I'm noticing the agent is constantly re-evaluating the discount for each item. It's inefficient! We need a way to store that calculated value so we don't repeat the computation.' Considering this feedback, which of the following best describes what the reviewer *intends* when they suggest an 'agent evaluation'? calculate_discount(item)The reviewer is focused on performance optimization – avoiding redundant calculations. 'Agent evaluation' in this context refers to a technique where the result of a function call (specifically,
calculate_discount()) is stored and reused instead of being recalculated each time. This addresses the inefficiency highlighted by the reviewer; options A, C, and D relate to different aspects of software development but don't directly address the core issue of avoiding repeated computations within the agent's workflow.9 / 37
Reviewer: 'I'm seeing a lot of calls to the `calculate_discount()` function here. It seems like the agent is repeatedly recalculating the discount based on the same items each time. Could you consider using an agent evaluation to store and reuse this calculated value, preventing redundant computation?' What does the reviewer mean by suggesting an 'agent evaluation' in this context?
The reviewer is referring to an agent evaluation, which is a core concept in agentic design. It's not about coding style or database queries, but rather the agent's ability to *remember* and reuse computed values – like the discount – instead of recomputing them every time. This optimizes performance by reducing unnecessary processing within the agent itself.
10 / 37
PR Description:
"Implemented the new loyalty program agent. This agent calculates discounts based on user purchase history and applies them to orders. I've used a loop to iterate through all items in the cart and apply the discount."The PR description focuses solely on the implementation details without considering potential optimization. The reviewer is highlighting that using a simple loop to calculate discounts repeatedly, especially for large carts, can lead to performance bottlenecks. An 'agent evaluation' in this context would represent a mechanism to store and reuse the calculated discount value—avoiding redundant computation and improving efficiency.
incorrect options present misunderstandings of the core principle: agent evaluations are about optimizing *how* calculations are performed, not just the basic implementation.11 / 37
Reviewer: 'I'm noticing the agent is constantly re-evaluating the discount for each item. It's inefficient! We need a way to store that calculated value so we don't repeat the computation.' Considering this feedback, which of the following best describes what the reviewer *intends* when they suggest an 'agent evaluation'? calculate_discount(item)The reviewer is focused on performance optimization – avoiding redundant calculations. 'Agent evaluation' in this context refers to a technique where the result of a function call (specifically,
calculate_discount()) is stored and reused instead of being recalculated each time. This addresses the inefficiency highlighted by the reviewer; options A, C, and D relate to different aspects of software development but don't directly address the core issue of avoiding repeated computations within the agent's workflow.12 / 37
Reviewer: 'I'm seeing a lot of calls to the `calculate_discount()` function here. It seems like the agent is repeatedly recalculating the discount based on the same items each time. Could you consider using an agent evaluation to store and reuse this calculated value, preventing redundant computation?' What does the reviewer mean by suggesting an 'agent evaluation' in this context?
The reviewer is referring to an agent evaluation, which is a core concept in agentic design. It's not about coding style or database queries, but rather the agent's ability to *remember* and reuse computed values – like the discount – instead of recomputing them every time. This optimizes performance by reducing unnecessary processing within the agent itself.
13 / 37
PR Description:
"Implemented the new loyalty program agent. This agent calculates discounts based on user purchase history and applies them to orders. I've used a loop to iterate through all items in the cart and apply the discount."The PR description focuses solely on the implementation details without considering potential optimization. The reviewer is highlighting that using a simple loop to calculate discounts repeatedly, especially for large carts, can lead to performance bottlenecks. An 'agent evaluation' in this context would represent a mechanism to store and reuse the calculated discount value—avoiding redundant computation and improving efficiency.
incorrect options present misunderstandings of the core principle: agent evaluations are about optimizing *how* calculations are performed, not just the basic implementation.14 / 37
Reviewer: 'I'm noticing the agent is constantly re-evaluating the discount for each item. It's inefficient! We need a way to store that calculated value so we don't repeat the computation.' Considering this feedback, which of the following best describes what the reviewer *intends* when they suggest an 'agent evaluation'? calculate_discount(item)The reviewer is focused on performance optimization – avoiding redundant calculations. 'Agent evaluation' in this context refers to a technique where the result of a function call (specifically,
calculate_discount()) is stored and reused instead of being recalculated each time. This addresses the inefficiency highlighted by the reviewer; options A, C, and D relate to different aspects of software development but don't directly address the core issue of avoiding repeated computations within the agent's workflow.15 / 37
Reviewer: 'I'm seeing a lot of calls to the `calculate_discount()` function here. It seems like the agent is repeatedly recalculating the discount based on the same items each time. Could you consider using an agent evaluation to store and reuse this calculated value, preventing redundant computation?' What does the reviewer mean by suggesting an 'agent evaluation' in this context?
The reviewer is referring to an agent evaluation, which is a core concept in agentic design. It's not about coding style or database queries, but rather the agent's ability to *remember* and reuse computed values – like the discount – instead of recomputing them every time. This optimizes performance by reducing unnecessary processing within the agent itself.
16 / 37
PR Description:
"Implemented the new loyalty program agent. This agent calculates discounts based on user purchase history and applies them to orders. I've used a loop to iterate through all items in the cart and apply the discount."The PR description focuses solely on the implementation details without considering potential optimization. The reviewer is highlighting that using a simple loop to calculate discounts repeatedly, especially for large carts, can lead to performance bottlenecks. An 'agent evaluation' in this context would represent a mechanism to store and reuse the calculated discount value—avoiding redundant computation and improving efficiency.
incorrect options present misunderstandings of the core principle: agent evaluations are about optimizing *how* calculations are performed, not just the basic implementation.17 / 37
Reviewer: 'I'm noticing the agent is constantly re-evaluating the discount for each item. It's inefficient! We need a way to store that calculated value so we don't repeat the computation.' Considering this feedback, which of the following best describes what the reviewer *intends* when they suggest an 'agent evaluation'? calculate_discount(item)The reviewer is focused on performance optimization – avoiding redundant calculations. 'Agent evaluation' in this context refers to a technique where the result of a function call (specifically,
calculate_discount()) is stored and reused instead of being recalculated each time. This addresses the inefficiency highlighted by the reviewer; options A, C, and D relate to different aspects of software development but don't directly address the core issue of avoiding repeated computations within the agent's workflow.18 / 37
During a standup meeting, Sarah says, "The agent is currently iterating over all customer records to determine if they meet the eligibility criteria for a premium offer. This is taking a significant amount of time.". What does Sarah likely mean when she suggests using an agent eval?
Sarah is referring to caching. An agent eval involves pre-computing and storing the result of an evaluation (in this case, determining eligibility) so that subsequent evaluations can reuse that result instead of re-running the entire process. This dramatically improves performance and reduces computational load – a core concept behind agent evals.
19 / 37
Mark is reviewing a PR containing an agent that calculates shipping costs based on destination and weight. He sees the following code snippet:
function calculateShipping(destination, weight) {
// Complex calculations here...
}
He comments: "This function is called repeatedly for every order item. It seems like we could use an agent eval to pre-calculate and store this value."
What is Mark primarily concerned about?Mark is highlighting a critical performance issue: redundancy. Calling the `calculateShipping` function repeatedly with the same parameters (destination and weight) is extremely inefficient. An agent eval would address this by pre-computing the result once and storing it, allowing subsequent calls to simply retrieve the cached value.
20 / 37
"The agent's logic needs a 'guard clause' to handle edge cases where the discount cannot be applied. We should implement an agent eval to evaluate if these conditions exist before calculating the discount."
Guard clauses are essential for handling invalid input or situations where the discount calculation isn't applicable. An agent eval is a technique to pre-compute these potential outcomes (e.g., checking if an item qualifies for a discount) and store them, preventing redundant calculations in those cases. This directly addresses efficiency.
21 / 37
In a Slack message to the team, David writes: "I'm seeing that the agent is constantly re-evaluating the customer's purchase history to determine their loyalty tier. It's really slowing things down! We need to use an agent eval to store this information."
What problem is David trying to solve?
David identifies a performance bottleneck: redundant calculations. By using an agent eval, the loyalty tier can be pre-calculated and stored, so subsequent calls don't require recalculating it from scratch. This is the core benefit of an agent eval – avoiding repeated computations.
22 / 37
"The agent is generating a discount code based on user activity. The calculation involves multiple API calls to retrieve customer data and product information. It's taking too long.", Which approach best addresses this issue according to the principles of Agentic Design?
An agent eval is designed to reduce redundant API calls. By pre-calculating and caching frequently accessed data (customer and product information), the agent can avoid repeatedly hitting the APIs, dramatically improving performance. This aligns directly with the goal of minimizing unnecessary computations.
23 / 37
During a standup meeting, Sarah says, "The agent is currently iterating over all customer records to determine if they meet the eligibility criteria for a premium offer. This is taking a significant amount of time.". What does Sarah likely mean when she suggests using an agent eval?
Sarah is referring to caching. An agent eval involves pre-computing and storing the result of an evaluation (in this case, determining eligibility) so that subsequent evaluations can reuse that result instead of re-running the entire process. This dramatically improves performance and reduces computational load – a core concept behind agent evals.
24 / 37
Mark is reviewing a PR containing an agent that calculates shipping costs based on destination and weight. He sees the following code snippet:
function calculateShipping(destination, weight) {
// Complex calculations here...
}
He comments: "This function is called repeatedly for every order item. It seems like we could use an agent eval to pre-calculate and store this value."
What is Mark primarily concerned about?Mark is highlighting a critical performance issue: redundancy. Calling the `calculateShipping` function repeatedly with the same parameters (destination and weight) is extremely inefficient. An agent eval would address this by pre-computing the result once and storing it, allowing subsequent calls to simply retrieve the cached value.
25 / 37
"The agent's logic needs a 'guard clause' to handle edge cases where the discount cannot be applied. We should implement an agent eval to evaluate if these conditions exist before calculating the discount."
Guard clauses are essential for handling invalid input or situations where the discount calculation isn't applicable. An agent eval is a technique to pre-compute these potential outcomes (e.g., checking if an item qualifies for a discount) and store them, preventing redundant calculations in those cases. This directly addresses efficiency.
26 / 37
In a Slack message to the team, David writes: "I'm seeing that the agent is constantly re-evaluating the customer's purchase history to determine their loyalty tier. It's really slowing things down! We need to use an agent eval to store this information."
What problem is David trying to solve?
David identifies a performance bottleneck: redundant calculations. By using an agent eval, the loyalty tier can be pre-calculated and stored, so subsequent calls don't require recalculating it from scratch. This is the core benefit of an agent eval – avoiding repeated computations.
27 / 37
"The agent is generating a discount code based on user activity. The calculation involves multiple API calls to retrieve customer data and product information. It's taking too long.", Which approach best addresses this issue according to the principles of Agentic Design?
An agent eval is designed to reduce redundant API calls. By pre-calculating and caching frequently accessed data (customer and product information), the agent can avoid repeatedly hitting the APIs, dramatically improving performance. This aligns directly with the goal of minimizing unnecessary computations.
28 / 37
During a standup meeting, Sarah says, "The agent is currently iterating over all customer records to determine if they meet the eligibility criteria for a premium offer. This is taking a significant amount of time.". What does Sarah likely mean when she suggests using an agent eval?
Sarah is referring to caching. An agent eval involves pre-computing and storing the result of an evaluation (in this case, determining eligibility) so that subsequent evaluations can reuse that result instead of re-running the entire process. This dramatically improves performance and reduces computational load – a core concept behind agent evals.
29 / 37
Mark is reviewing a PR containing an agent that calculates shipping costs based on destination and weight. He sees the following code snippet:
function calculateShipping(destination, weight) {
// Complex calculations here...
}
He comments: "This function is called repeatedly for every order item. It seems like we could use an agent eval to pre-calculate and store this value."
What is Mark primarily concerned about?Mark is highlighting a critical performance issue: redundancy. Calling the `calculateShipping` function repeatedly with the same parameters (destination and weight) is extremely inefficient. An agent eval would address this by pre-computing the result once and storing it, allowing subsequent calls to simply retrieve the cached value.
30 / 37
"The agent's logic needs a 'guard clause' to handle edge cases where the discount cannot be applied. We should implement an agent eval to evaluate if these conditions exist before calculating the discount."
Guard clauses are essential for handling invalid input or situations where the discount calculation isn't applicable. An agent eval is a technique to pre-compute these potential outcomes (e.g., checking if an item qualifies for a discount) and store them, preventing redundant calculations in those cases. This directly addresses efficiency.
31 / 37
In a Slack message to the team, David writes: "I'm seeing that the agent is constantly re-evaluating the customer's purchase history to determine their loyalty tier. It's really slowing things down! We need to use an agent eval to store this information."
What problem is David trying to solve?
David identifies a performance bottleneck: redundant calculations. By using an agent eval, the loyalty tier can be pre-calculated and stored, so subsequent calls don't require recalculating it from scratch. This is the core benefit of an agent eval – avoiding repeated computations.
32 / 37
"The agent is generating a discount code based on user activity. The calculation involves multiple API calls to retrieve customer data and product information. It's taking too long.", Which approach best addresses this issue according to the principles of Agentic Design?
An agent eval is designed to reduce redundant API calls. By pre-calculating and caching frequently accessed data (customer and product information), the agent can avoid repeatedly hitting the APIs, dramatically improving performance. This aligns directly with the goal of minimizing unnecessary computations.
33 / 37
During a standup meeting, Sarah says, "The agent is currently iterating over all customer records to determine if they meet the eligibility criteria for a premium offer. This is taking a significant amount of time.". What does Sarah likely mean when she suggests using an agent eval?
Sarah is referring to caching. An agent eval involves pre-computing and storing the result of an evaluation (in this case, determining eligibility) so that subsequent evaluations can reuse that result instead of re-running the entire process. This dramatically improves performance and reduces computational load – a core concept behind agent evals.
34 / 37
Mark is reviewing a PR containing an agent that calculates shipping costs based on destination and weight. He sees the following code snippet:
function calculateShipping(destination, weight) {
// Complex calculations here...
}
He comments: "This function is called repeatedly for every order item. It seems like we could use an agent eval to pre-calculate and store this value."
What is Mark primarily concerned about?Mark is highlighting a critical performance issue: redundancy. Calling the `calculateShipping` function repeatedly with the same parameters (destination and weight) is extremely inefficient. An agent eval would address this by pre-computing the result once and storing it, allowing subsequent calls to simply retrieve the cached value.
35 / 37
"The agent's logic needs a 'guard clause' to handle edge cases where the discount cannot be applied. We should implement an agent eval to evaluate if these conditions exist before calculating the discount."
Guard clauses are essential for handling invalid input or situations where the discount calculation isn't applicable. An agent eval is a technique to pre-compute these potential outcomes (e.g., checking if an item qualifies for a discount) and store them, preventing redundant calculations in those cases. This directly addresses efficiency.
36 / 37
In a Slack message to the team, David writes: "I'm seeing that the agent is constantly re-evaluating the customer's purchase history to determine their loyalty tier. It's really slowing things down! We need to use an agent eval to store this information."
What problem is David trying to solve?
David identifies a performance bottleneck: redundant calculations. By using an agent eval, the loyalty tier can be pre-calculated and stored, so subsequent calls don't require recalculating it from scratch. This is the core benefit of an agent eval – avoiding repeated computations.
37 / 37
"The agent is generating a discount code based on user activity. The calculation involves multiple API calls to retrieve customer data and product information. It's taking too long.", Which approach best addresses this issue according to the principles of Agentic Design?
An agent eval is designed to reduce redundant API calls. By pre-calculating and caching frequently accessed data (customer and product information), the agent can avoid repeatedly hitting the APIs, dramatically improving performance. This aligns directly with the goal of minimizing unnecessary computations.
Frequently Asked Questions
What will I practice in "Agentic Design Patterns Vocabulary | Coders Lingo"?
This is an AI Agents Language exercise set. It walks through 37 scenario-based multiple-choice questions built around real usage of AI Agents Language terminology that IT professionals encounter on the job.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to complete with no account, sign-up, or paywall.
How many questions are in this exercise?
This set contains 37 questions. Each one shows immediate feedback and a detailed explanation after you answer, so you learn the correct usage right away rather than waiting for a final score.
Do I need prior experience to complete this exercise?
No prior experience is required. Each question includes a full explanation covering the reasoning behind the correct answer, so the exercise itself teaches the AI Agents Language vocabulary as you go.
Can I retry the exercise if I get questions wrong?
Yes — use the "Try again" button on the results screen to reset your answers and go through all the questions again. There is no limit on attempts.
Is my progress saved?
Your answers and score for the current session are tracked in the browser as you go. No account or login is needed, and there is nothing to install.
What if I don't understand a term used in a question?
Read the explanation shown after you answer each question — it breaks down the correct term in plain English with a real-world example. You can also check the site Glossary for quick definitions.
How is this different from reading a blog article on the topic?
Exercises like this one are interactive drills that test and reinforce specific vocabulary through multiple-choice questions, while blog articles explain concepts in prose. Practising here after reading builds active recall, not just passive recognition.
Where can I find more AI Agents Language exercises?
See the AI Agents Language exercises hub for the full set of related pages, or browse all exercise categories from the main Exercises index.
Can I use this exercise to prepare for a technical interview?
Yes — AI Agents Language vocabulary comes up often in technical discussions and interviews. Pair this exercise with our dedicated Interview Preparation section for role-specific practice.