Agentic AI, Explained on Jorge Laurel

What Is AI, Really?

Mon, 01 Jan 0001 00:00:00 +0000

A note on this series. This is written for beginners, on purpose. I’m keeping explanations at a practical, conceptual level rather than a technical one. Several ideas here are described in generic terms rather than their full technical depth, most notably, I won’t be going into neural networks, the actual mathematical foundation that makes models like these possible. That’s a deep, worthwhile topic on its own, but it’s not where a novice needs to start. The goal of these seven lessons is to demystify AI agents enough that the hype becomes understandable, and, ideally, to spark enough curiosity that you go looking for the deeper technical material afterward.

From Chatbot to Agent

Mon, 01 Jan 0001 00:00:00 +0000

In Lesson 1 I established what a language model does on its own. That leaves the term “AI agent” to explain, and why it’s replacing “chatbot” or “assistant” everywhere right now.

The boundary isn’t a hard line. Real systems sit on a spectrum. A workflow can contain an LLM without being an agent, and a chat-based assistant can use tools without becoming a fully autonomous agent. The useful question isn’t “Is this definitely a chatbot or definitely an agent?” It’s “How much of the workflow does the system decide for itself, what tools can it use, and how much human control remains?”

The Building Blocks of an Agent

Mon, 01 Jan 0001 00:00:00 +0000

Many modern LLM-based agents can be understood through four common building blocks: a model, tools, some form of state or memory, and instructions or goals. Not every agent needs all four in the same form, but this framework is a useful way to understand most of the systems you’ll encounter.

1. The model (the brain)

This is the LLM from Lesson 1: Claude, GPT, Gemini, or an open-weight model like Meta’s Llama or Alibaba’s Qwen. The model reads the current situation and decides what should happen next. It doesn’t execute anything itself. It predicts, and in an agent, part of what it predicts is which action to take.

How an Agent “Decides” What to Do

Mon, 01 Jan 0001 00:00:00 +0000

Lesson 3 gave us the four building blocks: model, tools, memory, instructions. This lesson is about how they actually run together, because that mechanism is the real heart of “agentic AI.” It’s less magical than it sounds, and understanding it will make every agent product you encounter easier to evaluate.

The loop: think, act, observe, repeat

A useful way to picture many agents is as a repeating cycle:

Decide. The model looks at the goal and everything it knows so far, and decides what the next step should be.
Act. If that step requires a tool, the agent calls it: a web search, a file read, an API request, or another available action.
Observe. The result of that action comes back and gets added to what the model can see.
Repeat. The model looks at the updated picture and decides what to do next, continuing until the goal is met, it reaches a limit, or it hands control back to a person.

Some systems follow this pattern closely; others use upfront planning, fixed workflows, parallel steps, or combinations of these approaches.

Tools and Function Calling

Mon, 01 Jan 0001 00:00:00 +0000

Lesson 3 named tools as the agent’s hands. This lesson opens up how that actually works under the hood, because the mechanism, function calling, is one of the key pieces of engineering that lets language models move from generating text to operating software through external tools.

The basic mechanism

A model can’t literally reach out and click a button or run code. What it can do is output text in a very specific, structured format that says, in effect, “call this function, with these parameters.” The software running around the model watches for that structured output, recognizes it as a tool request, executes the function (a real API call, a database query, a web search), and feeds the result back to the model as new text for it to keep reasoning over.

Agentic Systems, When Agents Work Together

Mon, 01 Jan 0001 00:00:00 +0000

Everything so far has described a single agent: one model, running a loop, calling tools as needed. That’s plenty for a lot of tasks. For some complex agentic tasks in 2026, developers are also experimenting with multiple agents working together, and this lesson explains why and how that coordination happens.

Why one agent isn’t always enough

A single agent trying to handle a complex, multi-part task, say, “research five competitors, compare their pricing, draft a report, and flag anything that needs legal review,” tends to run into the same problem a single overworked employee would. It has to hold too much context at once, and quality drops as the task grows. Splitting the work across specialized agents, one that researches, one that compares, one that writes, one that reviews for risk, mirrors how a human team would naturally divide labor.

Real Examples, Putting It All Together

Mon, 01 Jan 0001 00:00:00 +0000

Six lessons in, I’ve covered the model, the chatbot-to-agent line, the four building blocks, the think-act-observe loop, tool calling, and multi-agent systems. This final lesson walks through three real-world-shaped examples, each one showing all of those pieces working together, without assuming you’ll ever write a line of code.

Example 1: A scheduled research and automation workflow

Picture a system that runs every morning without anyone touching it: it checks a handful of news sources for stories on a specific topic, uses a model to summarize and rank what it finds, and writes the result somewhere useful, a document, a message, a dashboard.

Glossary & Index

Mon, 01 Jan 0001 00:00:00 +0000

Plain-language definitions of the recurring terms used throughout this book, in the same practical spirit as the chapters themselves.

A2A (Agent-to-Agent protocol)
A communication standard that lets independent agents, built by different companies or on different frameworks, hand off tasks and status to one another.

Agent (AI agent)
A software system that can pursue a goal by making decisions, interacting with its environment, and taking actions, often using a language model and external tools.