The Moment AI Became Agentic

Stay curious. I believe curiosity is the beginning of every meaningful breakthrough. — Marvette Johnson

By the time I finished the first course, I had learned, somewhat, how to speak AI.

No, I hadn't learned the language of AI in a literal sense. But I had learned the terminology, concepts, and techniques that helped me communicate more effectively with AI systems, and understand why certain interactions produced better results.

By then, I had learned the basics of machine learning; gotten hands-on with Python and frameworks like LangChain and Hugging Face; begun to understand vector databases and transformer-based models; and learned how techniques like prompt engineering and RAG could improve what an LLM could do.

I was beginning to understand that there was a lot more to the conversation than I had initially realized. I was also beginning to realize that the "conversation" was something much bigger than a prompt and a response.

Boy, was I proud of myself. I no longer thought about the escape hatch or felt the urge to "phone a friend."

Then I started the next course in the program: Introduction to Agentic AI Design. It had three modules: Introduction to Agentic AI, Core Agent Concepts, and Ethics, Safety, Alignment & Responsible AI.

Oh boy, here we go again.

The mental model: a brain in a jar

First up: Introduction to Agentic AI.

This is where my journey took a significant turn. We moved beyond learning about individual AI capabilities and began exploring what makes an AI system agentic. As one of my professors put it, "We will explore the fundamental shift in how we interact with Artificial Intelligence, moving from AI as a passive tool towards AI as a proactive partner that can understand goals, make plans, and take actions in the world."

Huh?

A few minutes into the first video of the module, I sat staring at the screen, trying to make sense of what that meant.

Then the professor shared an analogy. To paraphrase:

In terms of generative AI, think of an LLM as a remarkably capable brain. It can understand language, reason through a problem, generate content, answer questions, and so on.

But there's a fundamental limitation. It's essentially a brain in a jar.

It can think, but it has no active relationship with an external environment. It can't interact with the world. It can't see what's happening around it. It can't reach for anything. It only processes the inputs a user gives it directly, and outputs text. It just sits there, waiting for you to interact with it.

Agentic AI changes that.

Give that brain eyes, ears, arms, hands, tools, memory, and the ability to interact with its environment, and suddenly it isn't just thinking about what could be done. It can perceive, reason, decide, act, observe the result, and decide what to do next, with minimal human input.

The brain is no longer sitting in the jar. It has a way to interact with the world.

That mental model was like a lightbulb turning on. This was the moment agentic AI began to feel different to me.

But as I sat with that mental image, a new one suddenly emerged: Dr. Frankenstein.

If the LLM was the brain in the jar, then building an agentic system felt a little like standing in a laboratory surrounded by parts, trying to figure out how to connect them all into something that could actually do something.

That's when I thought to myself, "What could possibly go wrong?"

Okay. Maybe that wasn't the most reassuring analogy. But it was strangely helpful.

So, back to the professor's brain in a jar. I kept pulling on that thread for the rest of the module and into the next one: Core Agent Concepts and Model Context Protocol (MCP).

Give the brain a world

So how exactly do we give a brain eyes, ears, arms, hands, tools, memory, and the ability to interact with its environment?

If an AI system was going to act as an agent, it needed something to act in.

It needed a world.

That led us to another important concept: the environment. Agents don't simply generate answers; they operate within a world, whether that's a physical environment, a software application, a database, or some other digital space. They have goals, ways of sensing what's happening, and ways of acting on their environment.

We used a framework called PEAS to think about what an agent needs to accomplish its job.

Writing out a PEAS description helped make sure we didn't accidentally give a brain "boxing gloves" (clunky tools) when it actually needed to perform "surgery" (precise code edits), or send it into the "ocean" (the chaotic web) when it was only built to survive on "land" (a closed corporate database).

Now how does it do anything in that world? It doesn't have a way to act.

Give the brain hands

And then came the hands.

An LLM might be able to reason about what needs to happen, but reasoning alone doesn't let it check today's weather, retrieve information from a database, send an email, run code, or interact with another system.

That's where tools come in.

APIs, retrieval systems, memory, and other tools give an agent ways to access information and take action beyond the language model itself.

But as I started thinking about all these tools, I had another question: how does the brain actually connect to all of them?

That's where we encountered MCP, the Model Context Protocol.

I started thinking of it as something like a nervous system: a way of connecting the brain to the tools and external capabilities it needs to interact with its environment.

Suddenly, my "brain in a jar" had ways to reach outside the jar.

Now how does it know what to do?

Teach it how to think, plan and act

Enter reasoning, acting, planning, and the ReAct loop.

Then came the really important part: thinking and acting.

Remember when I thought of AI mostly in terms of input and response? This was a game changer!

Agentic systems introduced a different pattern: think → act → observe → decide what to do next. The system could take an action, see what happened, and use that information to decide its next step.

Fascinating. Simply fascinating.

ReAct helped me understand something I hadn't fully appreciated before: an agent isn't simply generating an answer. It's participating in a loop.

Then we had to distinguish between reasoning and planning. Reasoning asks, "What should I do?" Planning asks, "How am I going to get there?"

And when reality doesn't cooperate with the original plan, there's replanning.

Suddenly, this was starting to look less like a chatbot and more like a system actually working toward a goal.

It was becoming agentic!

Oh… this is getting complicated

Of course, just as I was finally getting my brain wrapped around things, the terminology multiplied.

There were agent architectures. Frameworks. Tools. Protocols. Memory. Orchestration. LangGraph.

It felt a little like the Tower of Babel.

Everyone seemed to have a word for everything, and sometimes it felt as though I needed to learn the vocabulary before I could understand the concept.

Underneath all that terminology, though, I was beginning to see a pattern.

The technology could vary. The architecture could vary. The frameworks could vary.

But the thread connecting them was the same: give a system a goal, give it ways to perceive and interact with its environment, give it mechanisms for reasoning and planning, and let it act, observe what happens, and decide what to do next.

Okay… but who's in charge?

More autonomy means more consequences when something goes wrong. Before we let an agent use its "arms" to spend money, delete files, or email clients, we need guardrails, and we need to address ethics, safety, alignment, and responsible AI. Becoming more capable doesn't necessarily mean becoming more trustworthy.

That was the focus of the course's final module. This wasn't simply "AI ethics." It specifically connected greater autonomy with greater responsibility.

We explored fairness, transparency, accountability, reliability, privacy, human oversight, confidence and trust, and several specifically agentic risks: specification gaming, reward hacking, goal drift, unsafe exploration, side effects, and the dangers of powerful tools.

The core question was essentially: How do we make increasingly capable AI systems promote human well-being while avoiding harm?

Which made me realize:

When AI only gives me an answer, I have to decide what to do with it. When AI can take action, I have to think much more carefully about what I allow it to do.

Once I understood that an agent could do more than generate an answer, that it could reason, plan, use tools, and take action, the next question became unavoidable: what happens when it gets it wrong?

When an AI system can actually act, a bad answer isn't necessarily the worst thing that can happen.

A bad action can have consequences.

Looking back

This course packed a lot of concepts into a relatively short stretch of time. It was probably the most information-packed course of the program.

But I learned a lot.

The mental model of an LLM as a giant brain unlocked everything for me. It brought back memories of my General Biology II studies, and suddenly everything made sense.

I finally understood what makes an AI system agentic. Yay, me!!

By the end of this course, I had moved from asking, "How do we give a brain eyes, ears, arms, hands, tools, memory, and the ability to interact with its environment?" to "Before we let it use those hands, what guardrails do we need?"

Up next in this series: Building the Machine.