Episodic, semantic, and procedural memory — keeping agents informed without blowing the context window.
Key vocabulary
Episodic memory — records of specific past events.
Semantic memory — general knowledge and facts about the domain.
Procedural memory — how to perform tasks: steps, tools, decisions.
Context window — the limited token space the agent can see at once.
Memory store — external storage (vector DB, database) persisting memory across sessions.
0 / 25 completed
1 / 25
A support agent remembers that a user reported a billing error last week and references it now. This is an example of:
Episodic memory = memories of specific events: who, what, when. Enables personalisation and continuity across sessions. Stored in a database or vector store, retrieved via similarity search.
2 / 25
An agent knows that “JWT tokens expire after a configurable TTL and must be refreshed using the /refresh endpoint.” This is:
Semantic memory = general knowledge, not tied to a specific event. Typically encoded in the system prompt or retrieved from a knowledge base.
3 / 25
When an agent’s context window approaches its limit, context compression involves:
Context compression: summarise earlier turns rather than truncating blindly. Ask the LLM to write a memory summary of older steps, then replace those steps with the summary.
4 / 25
A memory store in an agentic system refers to:
Memory store = external persistence. Common implementations: vector database (semantic retrieval), key-value store (structured facts), SQL database (episodic records).
5 / 25
An agent that knows how to file a support ticket — which fields, which API, in what order — is drawing on:
Procedural memory = knowing how to do something. Often encoded in the system prompt as instructions or retrieved from a task playbook memory store.
6 / 25
During a code review of the user authentication service, Sarah notes that John's recent implementation uses `localStorage` to persist session tokens. Mark comments, 'That's risky; we need to consider potential XSS vulnerabilities and the lack of proper token rotation strategies. Shouldn't we be leveraging JWT refresh endpoints for enhanced security?' What is Mark most likely referring to?
Mark is highlighting the importance of JWT token rotation and its mitigation against XSS vulnerabilities. While `localStorage` offers convenience, it lacks built-in security features necessary to handle token refresh and expiration. Properly rotating tokens minimizes damage if a token is compromised, significantly improving security posture.
7 / 25
During a remote sprint planning meeting, David mentions needing to integrate with the new 'Hydra' API. Maria responds, 'Excellent! Remember that Hydra's documentation explicitly states rate limiting is enforced based on IP address and user agent. We need to implement robust retry logic and consider caching strategies to avoid being throttled.' What specific technical consideration is Maria highlighting?
Maria is referencing a critical aspect of third-party API integration – rate limiting. Many APIs, including Hydra, employ IP-based restrictions to manage traffic and prevent abuse. Therefore, robust retry logic (to handle temporary failures) and caching strategies are essential to avoid being throttled. The other options represent broader concerns but aren't the immediate focus of Maria's comment.
8 / 25
During a post-mortem discussion on the recent service outage, Liam states, "The root cause was identified as excessive logging volume impacting our Kafka cluster. We need to implement more granular filtering and consider asynchronous processing for log aggregation.". Ben replies, "But we already have that circuit breaker in place! It should have automatically throttled the requests to prevent overloading the system." What is Ben's statement primarily demonstrating a misunderstanding of?
Ben's statement reveals a misunderstanding that circuit breakers are primarily *reactive*. They're designed to stop traffic when a service is overwhelmed, but don't proactively prevent the overload from happening in the first place. The post-mortem highlights the need for preventative measures – granular filtering and asynchronous processing – to address the underlying cause of excessive logging volume before it impacts Kafka.
9 / 25
During a design discussion for a new microservice, Alex proposes using a NoSQL database due to its flexibility and scalability. Ben counters with, 'But we need strong consistency guarantees for our financial transactions! Shouldn't we be considering a relational database like PostgreSQL?' What is Ben most likely concerned about regarding Alex's proposal?
Ben is highlighting a crucial difference between NoSQL databases (often offering eventual consistency) and relational databases (providing strong ACID properties). While NoSQL offers scalability, financial transactions demand strict data integrity, making PostgreSQL's guarantees essential. Alex's proposal, without addressing this concern, could lead to significant operational and data integrity risks. The other options are valid considerations for NoSQL but aren't the primary driver of Ben's objection.
10 / 25
During a technical discussion about optimizing API calls to the 'Phoenix' service, Emily suggests caching responses directly in the client browser. David responds, 'That's a good thought, but we need to consider cache invalidation strategies. Phoenix updates its data frequently, and if our cached responses become stale, it could lead to displaying incorrect information or even trigger cascading errors. We should explore using a shared caching layer like Redis with appropriate TTLs and potentially implementing change notifications from Phoenix itself.' What is David primarily concerned about?
David's concern centers around data consistency – the risk of using outdated cached information from Phoenix. He correctly identifies that a lack of proper invalidation mechanisms would lead to stale data and potential problems with the application's logic. The other options are valid considerations for API design but aren't the primary focus of David's comment in this scenario.
11 / 25
During a code review of the user authentication service, Sarah notes that John's recent implementation uses `localStorage` to persist session tokens. Mark comments, 'That's risky; we need to consider potential XSS vulnerabilities and the lack of proper token rotation strategies. Shouldn't we be leveraging JWT refresh endpoints for enhanced security?' What is Mark most likely referring to?
Mark is highlighting the importance of JWT token rotation and its mitigation against XSS vulnerabilities. While `localStorage` offers convenience, it lacks built-in security features necessary to handle token refresh and expiration. Properly rotating tokens minimizes damage if a token is compromised, significantly improving security posture.
12 / 25
During a remote sprint planning meeting, David mentions needing to integrate with the new 'Hydra' API. Maria responds, 'Excellent! Remember that Hydra's documentation explicitly states rate limiting is enforced based on IP address and user agent. We need to implement robust retry logic and consider caching strategies to avoid being throttled.' What specific technical consideration is Maria highlighting?
Maria is referencing a critical aspect of third-party API integration – rate limiting. Many APIs, including Hydra, employ IP-based restrictions to manage traffic and prevent abuse. Therefore, robust retry logic (to handle temporary failures) and caching strategies are essential to avoid being throttled. The other options represent broader concerns but aren't the immediate focus of Maria's comment.
13 / 25
During a post-mortem discussion on the recent service outage, Liam states, "The root cause was identified as excessive logging volume impacting our Kafka cluster. We need to implement more granular filtering and consider asynchronous processing for log aggregation.". Ben replies, "But we already have that circuit breaker in place! It should have automatically throttled the requests to prevent overloading the system." What is Ben's statement primarily demonstrating a misunderstanding of?
Ben's statement reveals a misunderstanding that circuit breakers are primarily *reactive*. They're designed to stop traffic when a service is overwhelmed, but don't proactively prevent the overload from happening in the first place. The post-mortem highlights the need for preventative measures – granular filtering and asynchronous processing – to address the underlying cause of excessive logging volume before it impacts Kafka.
14 / 25
During a design discussion for a new microservice, Alex proposes using a NoSQL database due to its flexibility and scalability. Ben counters with, 'But we need strong consistency guarantees for our financial transactions! Shouldn't we be considering a relational database like PostgreSQL?' What is Ben most likely concerned about regarding Alex's proposal?
Ben is highlighting a crucial difference between NoSQL databases (often offering eventual consistency) and relational databases (providing strong ACID properties). While NoSQL offers scalability, financial transactions demand strict data integrity, making PostgreSQL's guarantees essential. Alex's proposal, without addressing this concern, could lead to significant operational and data integrity risks. The other options are valid considerations for NoSQL but aren't the primary driver of Ben's objection.
15 / 25
During a technical discussion about optimizing API calls to the 'Phoenix' service, Emily suggests caching responses directly in the client browser. David responds, 'That's a good thought, but we need to consider cache invalidation strategies. Phoenix updates its data frequently, and if our cached responses become stale, it could lead to displaying incorrect information or even trigger cascading errors. We should explore using a shared caching layer like Redis with appropriate TTLs and potentially implementing change notifications from Phoenix itself.' What is David primarily concerned about?
David's concern centers around data consistency – the risk of using outdated cached information from Phoenix. He correctly identifies that a lack of proper invalidation mechanisms would lead to stale data and potential problems with the application's logic. The other options are valid considerations for API design but aren't the primary focus of David's comment in this scenario.
16 / 25
During a code review of the user authentication service, Sarah notes that John's recent implementation uses `localStorage` to persist session tokens. Mark comments, 'That's risky; we need to consider potential XSS vulnerabilities and the lack of proper token rotation strategies. Shouldn't we be leveraging JWT refresh endpoints for enhanced security?' What is Mark most likely referring to?
Mark is highlighting the importance of JWT token rotation and its mitigation against XSS vulnerabilities. While `localStorage` offers convenience, it lacks built-in security features necessary to handle token refresh and expiration. Properly rotating tokens minimizes damage if a token is compromised, significantly improving security posture.
17 / 25
During a remote sprint planning meeting, David mentions needing to integrate with the new 'Hydra' API. Maria responds, 'Excellent! Remember that Hydra's documentation explicitly states rate limiting is enforced based on IP address and user agent. We need to implement robust retry logic and consider caching strategies to avoid being throttled.' What specific technical consideration is Maria highlighting?
Maria is referencing a critical aspect of third-party API integration – rate limiting. Many APIs, including Hydra, employ IP-based restrictions to manage traffic and prevent abuse. Therefore, robust retry logic (to handle temporary failures) and caching strategies are essential to avoid being throttled. The other options represent broader concerns but aren't the immediate focus of Maria's comment.
18 / 25
During a post-mortem discussion on the recent service outage, Liam states, "The root cause was identified as excessive logging volume impacting our Kafka cluster. We need to implement more granular filtering and consider asynchronous processing for log aggregation.". Ben replies, "But we already have that circuit breaker in place! It should have automatically throttled the requests to prevent overloading the system." What is Ben's statement primarily demonstrating a misunderstanding of?
Ben's statement reveals a misunderstanding that circuit breakers are primarily *reactive*. They're designed to stop traffic when a service is overwhelmed, but don't proactively prevent the overload from happening in the first place. The post-mortem highlights the need for preventative measures – granular filtering and asynchronous processing – to address the underlying cause of excessive logging volume before it impacts Kafka.
19 / 25
During a design discussion for a new microservice, Alex proposes using a NoSQL database due to its flexibility and scalability. Ben counters with, 'But we need strong consistency guarantees for our financial transactions! Shouldn't we be considering a relational database like PostgreSQL?' What is Ben most likely concerned about regarding Alex's proposal?
Ben is highlighting a crucial difference between NoSQL databases (often offering eventual consistency) and relational databases (providing strong ACID properties). While NoSQL offers scalability, financial transactions demand strict data integrity, making PostgreSQL's guarantees essential. Alex's proposal, without addressing this concern, could lead to significant operational and data integrity risks. The other options are valid considerations for NoSQL but aren't the primary driver of Ben's objection.
20 / 25
During a technical discussion about optimizing API calls to the 'Phoenix' service, Emily suggests caching responses directly in the client browser. David responds, 'That's a good thought, but we need to consider cache invalidation strategies. Phoenix updates its data frequently, and if our cached responses become stale, it could lead to displaying incorrect information or even trigger cascading errors. We should explore using a shared caching layer like Redis with appropriate TTLs and potentially implementing change notifications from Phoenix itself.' What is David primarily concerned about?
David's concern centers around data consistency – the risk of using outdated cached information from Phoenix. He correctly identifies that a lack of proper invalidation mechanisms would lead to stale data and potential problems with the application's logic. The other options are valid considerations for API design but aren't the primary focus of David's comment in this scenario.
21 / 25
During a code review of the user authentication service, Sarah notes that John's recent implementation uses `localStorage` to persist session tokens. Mark comments, 'That's risky; we need to consider potential XSS vulnerabilities and the lack of proper token rotation strategies. Shouldn't we be leveraging JWT refresh endpoints for enhanced security?' What is Mark most likely referring to?
Mark is highlighting the importance of JWT token rotation and its mitigation against XSS vulnerabilities. While `localStorage` offers convenience, it lacks built-in security features necessary to handle token refresh and expiration. Properly rotating tokens minimizes damage if a token is compromised, significantly improving security posture.
22 / 25
During a remote sprint planning meeting, David mentions needing to integrate with the new 'Hydra' API. Maria responds, 'Excellent! Remember that Hydra's documentation explicitly states rate limiting is enforced based on IP address and user agent. We need to implement robust retry logic and consider caching strategies to avoid being throttled.' What specific technical consideration is Maria highlighting?
Maria is referencing a critical aspect of third-party API integration – rate limiting. Many APIs, including Hydra, employ IP-based restrictions to manage traffic and prevent abuse. Therefore, robust retry logic (to handle temporary failures) and caching strategies are essential to avoid being throttled. The other options represent broader concerns but aren't the immediate focus of Maria's comment.
23 / 25
During a post-mortem discussion on the recent service outage, Liam states, "The root cause was identified as excessive logging volume impacting our Kafka cluster. We need to implement more granular filtering and consider asynchronous processing for log aggregation.". Ben replies, "But we already have that circuit breaker in place! It should have automatically throttled the requests to prevent overloading the system." What is Ben's statement primarily demonstrating a misunderstanding of?
Ben's statement reveals a misunderstanding that circuit breakers are primarily *reactive*. They're designed to stop traffic when a service is overwhelmed, but don't proactively prevent the overload from happening in the first place. The post-mortem highlights the need for preventative measures – granular filtering and asynchronous processing – to address the underlying cause of excessive logging volume before it impacts Kafka.
24 / 25
During a design discussion for a new microservice, Alex proposes using a NoSQL database due to its flexibility and scalability. Ben counters with, 'But we need strong consistency guarantees for our financial transactions! Shouldn't we be considering a relational database like PostgreSQL?' What is Ben most likely concerned about regarding Alex's proposal?
Ben is highlighting a crucial difference between NoSQL databases (often offering eventual consistency) and relational databases (providing strong ACID properties). While NoSQL offers scalability, financial transactions demand strict data integrity, making PostgreSQL's guarantees essential. Alex's proposal, without addressing this concern, could lead to significant operational and data integrity risks. The other options are valid considerations for NoSQL but aren't the primary driver of Ben's objection.
25 / 25
During a technical discussion about optimizing API calls to the 'Phoenix' service, Emily suggests caching responses directly in the client browser. David responds, 'That's a good thought, but we need to consider cache invalidation strategies. Phoenix updates its data frequently, and if our cached responses become stale, it could lead to displaying incorrect information or even trigger cascading errors. We should explore using a shared caching layer like Redis with appropriate TTLs and potentially implementing change notifications from Phoenix itself.' What is David primarily concerned about?
David's concern centers around data consistency – the risk of using outdated cached information from Phoenix. He correctly identifies that a lack of proper invalidation mechanisms would lead to stale data and potential problems with the application's logic. The other options are valid considerations for API design but aren't the primary focus of David's comment in this scenario.
What will I practice in "Agent Memory Vocabulary | Coders Lingo"?
This is an AI Agents Language exercise set. It walks through 25 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 25 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.