AWS Certified Generative AI Developer - Professional: Agent architecture: planner, executor, memory

Day 17, agent architecture, planner,

executive, memory. Day 17 is where the

exam quietly checks something very

important. Do you understand the

difference between calling an LLM and

building a system that can act? This is

a conceptual jump, not a technical one.

Imagine this. A massive earthquake hits

a city. The government deploys an AI

called the disaster response commander.

Its job is not to answer questions. Its

job is to do things. It must assess

incoming damage reports, request

satellite images, check shelter

capacity, coordinate supply deliveries,

and keep track of what has already been

done. This system cannot answer once and

stop. It must think, plan, act, observe

results, and remember that is an agent.

So, let's define this clearly. An agent

is an LLM driven system that can plan

steps, call tools, observe outcomes, and

decide what to do next. A chatbot

answers, an agent acts. This distinction

matters deeply on the exam. If AWS

mentions multi-step workflows, tool

calls, decision-making or orchestration,

you are no longer in chatbot land. You

are in agent architecture.

Every agent, every real one has three

core components. A planner, an

executive,

and memory. Remove any one of these and

the agent collapses.

Let's start with the planner. The

planner is the thinker. Its job is to

take a goal and break it into steps. It

decides what should happen next. In the

disaster response system, a human says,

"Set up emergency shelters for 2,000

people." The planner does not call APIs

yet. It thinks first check available

shelters. Then calculate total capacity.

Then identify shortages. Then request

supplies. This is reasoning about

actions not performing them. On the

exam, if you see words like task

decomposition, planning steps or

deciding actions, you are looking at the

planner. Next is the executive. The

executive is the doer. It does not think

creatively. It does not decide strategy.

It performs actions chosen by the

planner. In our disaster system, the

executive calls real tools. It calls a

GIS API to locate shelters. It calls an

inventory system to check supplies. It

calls a logistics service to request

deliveries. In AWS terms, the exeutor is

almost always implemented with Lambda

functions and APIs. The LLM decides what

to call. Lambda actually calls it. This

separation is critical. Now comes

memory. Memory is what prevents the

agent from being stupid. Without memory,

the agent forgets what it already did,

repeats actions, and loops endlessly.

Memory exists in two forms. Short-term

memory holds the current conversation

and recent tool results. This often

lives in the prompt context or session

state. Long-term memory stores things

that must persist. Past decisions,

historical facts, user preferences,

completed actions. This is usually

stored in a vector database or a regular

data store. In the disaster system,

memory remembers which shelters are

already full, which supplies have been

requested, and which decisions are

final.

Because of memory, the agent does not

ask for the same supplies twice. Now

visualize the full agent loop. A user

provides a goal. The planner reasons

about the next step. The executive

performs the action by calling tools.

The system observes the results. Memory

is updated. The planner decides what to

do next. And the loop repeats. If you

can explain this loop, you can answer

any agent architecture question on the

exam. Where do AWS services fit into

this? Amazon Bedrock provides the LLM

that acts as the planner. Lambda

functions act as the exeutor. Vector

stores or databases provide long-term

memory. Cloudatch and X-ray give you

tracing and observability. IM controls

which tools the agent is allowed to use.

If the exam asks how an agent interacts

with external systems, the correct

answer is the LLM plans. Lambda

executes.

Now, it's equally important to know when

not to use an agent. Agents are

powerful, but they are expensive and

complex. They are good at multi-step

workflows, dynamic decisions, and tool

orchestration. They are bad at simple

question and answer tasks, static

responses, or one-step jobs. If the

problem is simple, an agent is the wrong

solution. AWS penalizes overengineering.

Finally, watch for the exam traps. An

agent is not just a bigger prompt. Agent

memory is not only chat history. Tools

are not called directly by users. and

agent logic does not live entirely in

lambda. The correct mental model is

simple. The LLM decides, the executive

acts, memory persists. Here is the one

sentence to lock this in. The planner

thinks, the executive acts, memory

prevents stupidity. Say that once before

the exam. Final self- test. A system

must decide which APIs to call in what

order. And remember previous results.

What architecture is required? An agent

with a planner, exeutor, and memory.

That's day 17 mastered.