Dear Techies,
You've seen this pattern before
Think about the best colleague you've ever worked with. The one you could hand a task to and just trust it would get done.
You don’t give them a twenty-step plan. You give them a goal, a few constraints, and some context. They figure out the rest. Check in when they need to and make sensible decisions along the way.
That's exactly how an AI agent works. Not because agents are human, but because the logic behind them mirrors how competent people approach tasks.
And once you see that pattern clearly, everything about agents starts to make sense.
The loop: perceive, plan, act
Every AI agent runs the same three-step loop, on repeat, until the task is done.
Perceive
The agent looks at what's in front of it. What information does it have? What just happened? What changed since the last step? This isn't a one-time scan at the start. The agent perceives at every point in the loop, constantly updating its understanding of where things stand.
Plan
Based on what it just perceived, the agent decides what to do next. Not a ten-step master plan. Just the next move. Then it reassesses and plans the one after that. More like a chess player thinking a couple of moves ahead than a project manager mapping out a whole timeline.
Act
The agent does something in the real world. Sends an email. Runs a search. Updates a spreadsheet. Books a meeting. This is what separates agents from chatbots. Chatbots talk to you. Agents reach out and do things.
Then the loop starts again. Perceive the result. Plan the next step. Act on it. Repeat until done, or until the agent gets stuck and comes back to you.
That's it. That's the entire logic behind every AI agent you'll ever encounter.
Why this matters when you start building
Here's the practical part.
When you set up an agent, you're not writing code. You're essentially describing three things in plain English. What should the agent pay attention to. How should it decide what to do. What tools can it use to get things done.
Perceive. Plan. Act. That's what your instructions map to, whether you realize it or not.
Which means that when an agent doesn't work the way you expected, the fix usually lives in one of those three places. Not buried in some technical setting. Right there in the loop.
The three-question diagnostic
When your agent does something unexpected, ask these three questions. In this order.
Is it perceiving the right information?
This is the most common problem and the easiest to miss. You asked the agent to sort your emails, but you forgot to give it access to your inbox. You asked it to prep for meetings, but it can't see your calendar. The agent isn't broken. It just can't see what it needs to see.
Before you change anything else, check what the agent has access to. Nine times out of ten, the fix is here.
Is it planning well?
If the agent can see everything it needs but still makes bad decisions, the issue is usually your instructions. Not because you wrote them badly, but because you left something out that felt obvious to you.
"Sort my emails" is too vague. Sort by what? Urgency? Topic? Sender? When should it flag something for you versus handle it on its own?
The fix is usually one or two more sentences of clarity. You're not programming. You're being more specific about what you want. The same way you would with a new colleague who's eager but doesn't know your preferences yet.
Is it missing a tool?
Sometimes the agent knows what to do but literally can't do it. You asked it to send a summary by email, but you didn't connect your email account. You asked it to update a spreadsheet, but there's no spreadsheet tool enabled.
This one is usually easy to spot. The agent will either skip the step, flag an error, or do a strange workaround that makes it obvious something is missing.
Three questions. Perceive, plan, act. That's your diagnostic checklist for every agent you build.
See it in action
Let's say you've set up an agent that prepares a brief before every meeting on your calendar. It's running. But the briefs are useless. Generic summaries that don't tell you anything you didn't already know.
Here's how you'd use the checklist.
Check perceive.
Can the agent see the full calendar event? Title, description, attendees, time? Or is it only getting the title? If all it sees is "Q3 Review" with no other details, it doesn't have enough context to write anything useful.
Fix: make sure the full event data is accessible.
Check plan.
It has all the data, but the output is still bland. Did you tell it what a good brief looks like? Did you say you want key topics identified, preparation tasks flagged, and questions suggested? Or did you just say "write a meeting prep brief"?
Fix: add two or three sentences describing what useful looks like to you.
Check act.
Is the brief arriving where it should? If the agent writes a great brief but you never see it, the delivery tool might not be connected properly.
Fix: verify the output channel, whether that's email, a notification, or a document.
Three checks. Problem found. Move on.
One thing to do before next week
Take the task descriptions you wrote after last week's newsletter. Pick one. Break it down using the loop.
Perceive:
What information does the agent need? Where does that information live?
Plan:
What rules should it follow? What decisions does it need to make? When should it check with you?
Act:
What tools does it need? Email? Calendar? Web search? A spreadsheet?
Here's what that might look like:
Task: Prep brief before every meeting.
Perceive: Calendar events, including title, description, attendees, and time.
Plan: Identify what the meeting is about, list who's attending, suggest two to three things to prepare, flag any open questions. If the event has no description, flag it as "needs context" instead of guessing.
Act: Send the brief to my email thirty minutes before the meeting starts.
That's not just an exercise. That's a set of agent instructions. When we get to the build stage in this series, you'll already have your brief written.
Want to see the loop working on screen?
This week's video traces the perceive-plan-act loop through a step-by-step email sorting example. Three emails, three cycles, same pattern every time. It makes the concept click in a way that reading alone doesn't quite capture.
👉 Watch the video: Video Link
Before you go
If this is helping you make sense of AI agents, share it with someone who's been curious but hasn't started yet. This series is built for exactly that person.
Stay Savvy,
Ijeoma | Tech Savvy Starts Here
P.S. Next week we actually build one. Live, on screen, from scratch. If you've been following along and writing your instructions, you'll be ready. If you haven't, there's still time. This week's exercise is the brief you'll use.
Enjoyed this edition?
Forward it to a friend or colleague who will enjoy it as well.
Missed something? Catch up in the newsletter archive.
🧠 Keep learning. | 💬 Keep questioning. | 💥 Keep growing.

