5 exercises — Master the vocabulary of autonomous AI systems: ReAct loops, memory types, multi-agent orchestration, reflection, and observability.
0 / 14 completed
1 / 14
A developer reviews an agent run trace that shows the following repeating pattern:
Thought: The user wants the current weather in London. I should call the weather tool. Action: get_weather(location="London") Observation: {"temp": 14, "condition": "cloudy"} Thought: I now have the data needed to answer. Final Answer: It's 14 °C and cloudy in London.
What architecture pattern does this trace demonstrate?
ReAct (Reason + Act) is the foundational pattern for tool-using agents.
In the ReAct pattern, the LLM alternates between reasoning ("Thought") and acting ("Action"), then incorporates the tool result ("Observation") into the next reasoning step. This repeating cycle — Thought → Action → Observation → Thought — constitutes the agent loop.
Pure chain-of-thought (B) produces intermediate reasoning steps but makes no tool calls. The planner-executor pattern (D) splits planning and execution into two separate LLM calls. ReAct uses a single LLM that both reasons and acts within the same loop — making it the building block of most single-agent frameworks (LangChain AgentExecutor, LlamaIndex ReActAgent).
Key vocabulary:
• ReAct — Reason + Act; an agent pattern interleaving reasoning steps with tool actions
• thought — the agent's internal reasoning step, visible in the trace
• action — a tool or function call issued by the agent
• observation — the tool's result returned to the agent for the next reasoning step
• agent loop — the repeating Thought → Action → Observation cycle that drives a ReAct agent
2 / 14
An agent system design document describes memory architecture as follows:
"The agent keeps the current conversation in a sliding-window buffer (in-context memory), summarises older turns into a vector store (semantic memory), and retrieves step-by-step coding workflows from a separate procedural store."
Which memory type specifically stores how to perform a task — step-by-step workflows, procedures, and reusable skills?
Procedural memory stores "how to do things" — workflows and reusable skills.
Borrowing from cognitive science, agent memory systems are often classified into four types:
• Episodic — specific past events ("what happened in last week's session?")
• Semantic — general world knowledge independent of specific episodes
• Procedural — step-by-step instructions and skills ("how to deploy a service")
• In-context / working memory — the current conversation window; bounded by the model's context limit
Storing procedures separately allows the agent to retrieve the right workflow on demand without filling the context window with irrelevant content. It also lets the workflow library grow independently of the model's context size.
Key vocabulary:
• episodic memory — memory of specific past events or prior interactions
• semantic memory — general world knowledge independent of specific events
• procedural memory — stored workflows, instructions, and skills the agent can retrieve and execute
• in-context memory — the active conversation window; limited by context window size
• external memory — memory stored outside the context window, typically in a vector database
3 / 14
A PR description reads: "The orchestrator agent receives the user's research task and decomposes it into sub-tasks — delegating web search to the researcher agent and citation formatting to the writer agent. Each returns its result; the orchestrator synthesises the final report."
Which role is the orchestrator performing?
The orchestrator decomposes goals and manages the team of sub-agents.
In multi-agent systems, the orchestrator (also called supervisor or manager agent) receives the top-level user goal, breaks it into smaller sub-tasks, and delegates each to a specialist sub-agent. Once sub-agents return their results, the orchestrator aggregates or synthesises them into the final output. This hub-and-spoke coordination pattern is implemented by frameworks like LangGraph, AutoGen, and CrewAI.
Crew (D) refers to the entire collection of agents — the orchestrator and all sub-agents together. An executor (C) is a component that runs code or tool calls, not one that delegates. A sub-agent (A) is the recipient, not the delegator.
Key vocabulary:
• orchestrator — the master agent that decomposes tasks and manages sub-agents
• sub-agent — a specialist agent that executes a delegated sub-task
• handoff — the moment the orchestrator passes a task or conversation control to a sub-agent
• crew — the full collection of agents with defined roles working toward a shared goal
• task decomposition — breaking a complex goal into smaller, independently executable sub-tasks
4 / 14
An agentic pipeline is described as follows: "The planner LLM generates a multi-step plan. The executor agent runs each step. After each step, a critic component evaluates the output — and if quality is insufficient, signals the planner to revise the remaining plan."
What role does the critic play in this architecture?
The critic enables the agent to reflect on its own output and self-correct.
The plan-and-execute pattern separates planning from execution. Adding a critic (or reflection) step after each execution creates a reflection loop: execute → evaluate → revise (if needed) → execute again. This self-correction capability distinguishes agentic systems from single-pass pipelines — the agent can detect when a step's result is wrong or incomplete and course-correct before finalising the output.
Safety filtering (A) happens before execution. Ranking candidate plans (B) is a planning-phase activity. Observability logging (D) is passive — it records but does not trigger revision.
Key vocabulary:
• plan-and-execute — an agentic pattern where a planner LLM produces a plan that an executor carries out
• critic — a component (LLM call or rule-based check) that evaluates step outputs and triggers correction
• reflection loop — the cycle of execute → critique → revise until quality criteria are met
• self-correction — an agent's ability to identify and fix its own errors during a run
• revision — updating the plan in response to critic feedback
5 / 14
An engineer opens LangSmith and sees an agent run record: "Trace ID: abc123 | Total tokens: 4 200 | Steps: 7 | Latency: 12.4 s | 3 child spans (tool calls)"
What does a span represent in agent observability?
A span is a single unit of work within a trace, with its own timing and I/O.
Agent observability borrows the trace/span model from distributed systems tracing (OpenTelemetry). A trace represents the full lifecycle of a task — from the user's first input to the final answer. Nested within the trace are spans, each representing one discrete operation: an LLM call, a tool call, a retrieval step, or a sub-agent invocation. Each span records start time, end time, token counts, inputs, and outputs.
Child spans are spans nested inside a parent span — for example, a tool call span nested inside an LLM call span. By analysing spans individually, you can identify which step consumes the most tokens, introduces the most latency, or fails most often — targeted LLMOps observability rather than only aggregate metrics.
Key vocabulary:
• trace — the complete record of an agent run from first input to final output
• span — a discrete unit of work (LLM call, tool call) within a trace, with timing and I/O recorded
• child span — a span nested inside a parent span (e.g., a tool call within an LLM call)
• token budget — the maximum tokens allocated to a single agent step to control cost and context usage
• step log — a sequential record of all actions and results in a single agent run
6 / 14
During a code review of an agent's Python script, Sarah notices the following pattern: thought = "The user wants to translate 'Hello World' into Spanish. I should call the translation tool."
action = translate(text="Hello World", target_language="es"). The response is {'translation': 'Hola Mundo'}. Which of the following best describes the agent's exhibited behavior?
The agent is responding directly to the user's request by calling a function (translate) with specific parameters. This illustrates a functional approach where the agent executes a pre-defined action based on the input, rather than engaging in complex semantic understanding or code generation. Option A suggests a deeper level of comprehension that isn't present here; options C and D are too elaborate for this simple example.
7 / 14
In a Slack message to the team, Alex writes: 'The agent is struggling with ambiguity in user prompts. We need to implement a more robust mechanism for clarifying intent – perhaps using a conversational memory layer to track the ongoing dialogue.' What does 'conversational memory layer' most likely refer to within this context?
'Conversational memory layer' directly relates to maintaining context within a dialogue. It's the agent's internal state that holds information about the ongoing conversation – the previous turns, user goals, and any relevant details. Options A, C, and D all represent different data storage or rule-based mechanisms, but don't address the core concept of remembering a chat's progression.
8 / 14
A PR description states: 'We've integrated LangSmith to monitor the agent's performance. The trace for this run shows a 'tool call' to a summarization tool – specifically, summarize(text=agent_output). This allows us to analyze the quality of the summary generated by the tool.' What is the primary purpose of monitoring 'tool calls' like this?
Monitoring tool calls is crucial for debugging and understanding the flow of information within an agent system. By observing which tools are called and how they're used (e.g., summarize), developers can identify issues with the data being passed to the tool or the results it produces, without needing to delve into the core agent logic itself. It's about validating external component usage.
9 / 14
During a standup meeting, David explains: 'The agent is now using a critic module to evaluate the quality of its generated code. If the critic deems the code below a certain standard – for instance, based on complexity metrics – it signals the planner to generate an alternative.' What role does this 'critic' component primarily fulfill?
The critic acts as a quality control mechanism. It doesn't generate new code or deploy it; instead, it assesses the existing output based on defined metrics (like complexity) and provides feedback to the planner, initiating a corrective action – in this case, generating alternative solutions. The key is its role as an *evaluator*.
10 / 14
Sarah is reviewing a PR for an agent that uses a vector store. The commit message reads: 'Improved retrieval accuracy by leveraging semantic embeddings and updating the vector database with new context.' Which of the following best describes the purpose of this action in the context of an LLM agent's memory system?
The description highlights 'semantic embeddings,' which means the agent isn't just storing text; it's understanding the *meaning* behind the words. This allows the agent to retrieve information based on similarity – finding relevant context even if the exact words aren't present in the current prompt. Option A is incorrect because semantic similarity goes beyond simple data addition.
11 / 14
Alex, a senior engineer, receives this Slack message from a junior developer: 'The agent's struggling with multi-turn conversations. It's losing context and generating repetitive responses.' Which of the following architectural components would be MOST beneficial to address this issue? 'Implementing a conversational memory layer.'
The core problem is the agent's inability to retain information across multiple turns. A 'conversational memory layer' – specifically designed to track dialogue history – directly addresses this by storing and retrieving relevant context from previous exchanges. Options B, C, and D are all valuable techniques but don't directly solve the fundamental issue of lost context within a multi-turn conversation.
12 / 14
David is presenting an update during a standup meeting. He says: 'We're integrating a critic module into the agent to evaluate the quality of its generated code based on complexity metrics.' What does this 'critic' component likely do? 'It assesses the agent's output against predefined rules or benchmarks for code quality, potentially rejecting outputs that exceed acceptable thresholds.'
The key phrase is 'evaluate against predefined rules.' A critic module doesn't *fix* the code; it judges its quality. This typically involves comparing the generated output (the code) against established standards – like complexity metrics – and flagging anything that falls outside acceptable limits. Options A and B are incorrect because they describe different approaches to code improvement.
13 / 14
Ben is reviewing a PR description for an agent designed to summarize long documents. The description states: 'The agent utilizes LangSmith's trace functionality to monitor the performance of its summarization tool – specifically, `summarize(text=agent_output)` – allowing us to identify bottlenecks and optimize latency.' What does the 'trace' data provided by LangSmith primarily provide? 'Detailed metrics on individual tool calls, including execution time, token usage, and error rates.'
LangSmith traces provide granular insights into *how* the agent is using its tools. The 'trace' data focuses on individual tool calls – in this case, the `summarize` function – allowing developers to pinpoint performance bottlenecks (like high latency) and identify potential issues within that specific tool interaction.
14 / 14
Chris is debugging an agent that's consistently failing to complete tasks. He notices the following log entry: 'Agent attempted to call a data enrichment tool with invalid parameters.' Which of the following represents the MOST likely cause of this failure? 'The agent's planning module incorrectly generated the request for the enrichment tool, leading to an incorrect parameter set.'
While outages and ambiguous prompts can cause failures, this log entry specifically points to an issue with the *planning* stage – where the agent decides which tool to call and what parameters to send. If the planning module generates incorrect requests (e.g., wrong parameter values), it's likely the root cause of the problem.
What will I practise in "AI Agent & Agentic System Vocabulary — LLM App Development Exercises"?
Practice AI agent vocabulary in English: ReAct pattern, agent memory types, multi-agent orchestration, reflection loops, and observability traces. 5 advanced exercises.
How many exercises are in this module?
This module has 14 multiple-choice exercises, each with instant feedback and a full explanation of the correct answer.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account, sign-up, or paywall.
Do I need to create an account to do these exercises?
No account is required. Just click an option to answer — your score for this session is tracked automatically in the progress bar above.
What happens if I choose the wrong answer?
You'll immediately see which answer was correct, plus a full explanation covering the vocabulary and reasoning behind it — mistakes are where most of the learning happens.
Can I retry the exercises if I want a higher score?
Yes — use the "Try again" button on the results screen to reset and go through all the questions again.
Is my progress saved if I close the page?
No. Progress is tracked only for your current visit; reloading or leaving the page resets the counter. This keeps the exercise simple and account-free.
Where can I find more LLM App Development exercises?
Browse the full LLM App Development hub for related drills, or check the "Next up" link below to continue with a connected topic.
How is this different from reading an article on the same topic?
Articles explain vocabulary and concepts in prose; this exercise tests and reinforces that vocabulary through active recall with immediate feedback — the two work best together.
Who writes these exercises?
Every exercise is written by the CoderSlingo team, drawing on real workplace English used in IT roles, then reviewed for accuracy and clarity.