Advanced AI Agents #planner-executor #reflection #memory #RAG

Agentic Design Patterns

5 exercises — master the vocabulary of advanced agent architectures: planner-executor separation, reflection loops, three-tier memory, RAG, and event-driven proactive agents.

0 / 5 completed

Agentic patterns vocabulary quick reference

Planner-executor — planner creates a multi-step plan; executor carries out each step
Reflection loop — agent evaluates its own output and iteratively revises it
Critique agent — a specialist agent whose role is to evaluate another agent's output
In-context memory — current conversation window (limited by context size)
Episodic memory — stored past interactions, retrieved by user/session ID
Semantic memory — factual knowledge stored in a vector database
RAG — Retrieval-Augmented Generation: retrieve docs → inject into prompt → generate grounded output
Event-driven agent — triggers autonomously based on external events or schedules

1 / 5

What is the "planner-executor" agentic pattern?

2 / 5

What is the "reflection loop" agentic pattern (also called self-refinement or critique-and-revise)?

The reflection loop is how agents improve their own outputs without human intervention.

The reflection cycle:

① Generate — agent produces an initial output (draft, code, plan)
② Reflect — agent (or a separate critic agent) evaluates the output:
"This code has no error handling. The SQL query could be vulnerable to injection. The function name is unclear."
③ Revise — agent rewrites the output based on its own critique
④ Repeat — continue until quality threshold met, or revision limit reached

Reflection patterns:

Pattern	Description
Self-reflection	Same agent evaluates and revises its own output
Critic agent	Separate specialist agent provides structured critique
Scoring threshold	Reflection continues until output scores above N%

Key vocabulary:
• Reflection — the agent examining its own output critically
• Critique agent — a specialist agent whose role is to evaluate and critique another agent's output
• Max revisions — the stopping condition for the reflection loop (prevents infinite refinement)
• Self-refinement — the broader category of techniques where models improve their own outputs

3 / 5

An AI agent system uses three types of memory: ① facts stored in a vector database, ② the conversation history in the current session's messages array, and ③ summarised past interactions stored in a database keyed by user ID. What are these three types of agent memory called?

The three-tier agent memory architecture maps directly to how humans store and retrieve knowledge.

Memory type	Storage	What it contains	Retrieval
In-context	LLM context window	Current conversation, recent steps	Direct (always visible)
Episodic	Database / file store	Past conversations, session logs	Lookup by user/session ID
Semantic	Vector database	Facts, documents, knowledge	Nearest-neighbour search

Some frameworks also add:
• Procedural memory — stored workflows or instructions the agent can reference
• Working memory — a scratchpad within the context window for intermediate calculations

Why memory architecture matters:
Without episodic memory, the agent starts fresh with every session — it cannot personalise or learn from past interactions. Without semantic memory, the agent cannot access domain knowledge beyond its training data.

Key vocabulary:
• In-context memory — what the agent currently "sees" (limited by context window size)
• Episodic memory — records of past experiences, retrieved by identity or time
• Semantic memory — factual knowledge, retrieved by content similarity

4 / 5

What is the "RAG" pattern (Retrieval-Augmented Generation) when used inside an agent loop?

RAG inside the agent loop extends the agent's knowledge beyond its training cutoff and static parametric knowledge.

RAG in an agent step:

① Agent decides it needs context — e.g. "I need current documentation for Kubernetes v1.30"
② Retrieval — agent calls a retrieval tool: search_docs(query="kubernetes v1.30 new features", top_k=5)
③ Documents returned — 5 most relevant chunks from the vector store
④ Augmented generation — the LLM generates its response with retrieved chunks in its prompt context

RAG vs parametric knowledge:

	Parametric (training)	RAG (retrieved)
Currency	Up to training cutoff	Real-time
Hallucination risk	Higher	Lower (grounded)
Updatable	Requires fine-tuning	Update the index

Key vocabulary:
• Retrieval — fetching relevant documents from an external knowledge source
• Augmentation — injecting retrieved content into the prompt context
• Grounding — anchoring agent responses in retrieved evidence to reduce hallucinations
• Vector store — the database storing encoded document embeddings for similarity search

5 / 5

An engineering team reviews their agent architecture. A senior engineer says: "Right now the agent is purely reactive — it just responds to user queries. We want to add a proactive mode where it monitors conditions and acts without being asked."

Which agentic pattern vocabulary correctly describes what they're proposing?

Option C uses precise agentic pattern vocabulary to describe the shift from reactive to proactive agency.

Reactive vs proactive agents:

	Reactive agent	Proactive / Event-driven agent
Trigger	Human sends a message	External event, schedule, or condition
Initiation	User-initiated	System-initiated
Examples	Chatbot, Q&A assistant	Monitoring agent, auto-responder

Proactive agent trigger types:
① Scheduled trigger — cron-style: "Run the inventory check agent every morning at 06:00"
② Event trigger — subscribe to events: "Run when a new support ticket with severity=critical is created"
③ Threshold trigger — condition monitoring: "Run when CPU usage exceeds 90% for >5 minutes"
④ Webhook trigger — external system calls the agent's endpoint

Key vocabulary:
• Event-driven agent — agent that triggers autonomously based on external events
• Trigger-based agent — alternative name, emphasizing the activation mechanism
• Autonomous agent — operates without direct human requests
• Agent scheduling — running agent runs on a time-based schedule
• Proactive agency — the property of acting without explicit user requests