How Agentic AI Thinks, Acts, and Remembers

Why You Need a Mental Model

Sometimes you'll use agentic systems built by someone else. Other times, you'll be the one building them — or at least helping shape what an agent should do. Either way, it helps to have a clear mental model of what actually happens behind the scenes.

Throughout this course, I'll keep returning to four simple words:

Perception → Reasoning → Action → Memory

Don't get too hung up on the vocabulary. You may hear others say observing instead of perceiving, or planning instead of reasoning. The words matter less than the ideas behind them.

The Human Analogy

At its core, an agent does exactly what humans do when working toward a goal:

Notice what's going on → Perception
Figure out what to do → Reasoning
Actually do something → Action
Remember what matters → Memory

Let's unpack each one.

1. Perception — How the Agent Notices the World

Perception is how the agent gathers information. It covers two things:

How the agent gets data — from files, APIs, databases, or messages.
How the agent is triggered — the event that causes it to spring into action.

A trigger can be almost anything:

A prompt written by a user
An incoming email or text message
A file dropped into a specific folder
A change in a calendar event
New data pulled from an external API
A scheduled run (e.g., every weekday at 7:00 AM)
A task specifically assigned to that agent

Whatever the trigger is, this is where the agent's journey begins — by taking in input and making sense of it.

2. Reasoning — Where the Agent Figures Things Out

Reasoning is the thinking stage, usually powered by a Large Language Model (LLM).

This is one of the biggest differences between agentic systems and traditional automation.

Traditional Automation	Agentic Reasoning
Follows fixed rules and flowcharts	Creates new plans on the fly
"If this, then that"	Handles ambiguous goals
Rigid	Flexible and adaptive

Modern agentic AI is built on top of the recent success of generative AI, because LLMs are surprisingly good at reasoning — even when goals are messy, open-ended, or unpredictable.

During this stage, an agent might:

Break a big goal into smaller subtasks
Ask follow-up questions
Decide it needs to look something up
Choose the right tool for the next step

But Wait — How Does It Know What to Focus On?

The agent isn't just an open-ended chatbot. Before it ever receives a goal, it has already been given instructions — written in plain language — that shape how it reasons.

For example:

"You are a business analyst who turns plain language requests into SQL queries."

Or:

"You are a marketing assistant who drafts and schedules social media posts based on product updates."

These prompts don't just tell the agent what it is. They guide how it reasons — what's in scope, what to prioritize, and what to ignore.

So when we say an agent "reasons," it's not freestyling. Its reasoning is shaped, bounded, and directed by carefully written instructions.

And yes — if this sounds a bit like programming, that's because it is. You're not writing traditional code, but you are writing instructional logic:

"If this happens, prefer doing that."
"If stuck, try this tool first."
"Always prioritize accuracy over speed."

The more complex the agent, the more structured this instructional logic needs to be.

3. Action — Where the Agent Actually Does Things

This is the doing part — and it's what separates a real agent from a plain LLM.

A regular chatbot can only generate text. An agent, however, can:

Send emails
Search the web
Call other applications and APIs
Write to documents
Summarize content
Perform calculations
Trigger additional workflows
Execute any step in a plan

In other words, an agent doesn't just talk about a goal — it acts on it. It reaches into other systems and moves things forward in the real world.

4. Memory — Where the Agent Keeps Track

Memory lets the agent remember:

What it has already done
What it already knows
What still needs to happen

There are two flavors:

Type of Memory	What It Stores
Short-term Memory	Context within a single session or goal
Long-term Memory	Persistent knowledge — user preferences, past interactions, learned patterns

Not every agent needs memory. Some just complete a task and move on. But most agentic systems benefit from memory because it helps them:

Avoid repeating themselves
Follow long-running goals
Improve and get smarter over time

A Common Point of Confusion

The LLM is not the agent.

Whether you're using GPT, Claude, Gemini, or any other model — the LLM is just one part of a larger system. It's usually responsible for the reasoning step (though sometimes it appears in other parts too).

On its own, an LLM can't take action. It just responds to prompts.

What Makes Something Truly Agentic

It's the wiring of all the pieces together:

A goal to pursue
Tools it can use
Memory to track progress
Reasoning to make decisions
Actions to change the world

When you connect these pieces together, you no longer have just an LLM — you have an agent.

Key Takeaway

An agent is a system, not a model.

It perceives what's happening, reasons about what to do, acts on that reasoning, and remembers what matters — all in pursuit of a goal.

That's the mental model. Everything else in agentic AI is just an elaboration of these four ideas.

Quick Recap

Capability	What It Does	Example
Perception	Gathers information and detects triggers	Reads a user prompt or new email
Reasoning	Plans, decides, and adapts using an LLM	Breaks a goal into subtasks
Action	Executes tasks in the real world	Sends email, calls an API
Memory	Stores context and learning	Remembers user preferences

Pro Tip for Learners: Whenever you evaluate or design an agentic system, always ask — How does it perceive? How does it reason? What can it act on? What does it remember? These four questions will unlock any agentic architecture you encounter.