What Is Agentic AI?

Picture asking a regular chatbot to "book me a table for four on Friday." The best it can do is tell you how to book one. It produces text and stops. It cannot open a reservations site, check availability, hold a slot, or email you a confirmation. Now imagine the same request handled by a system that actually opens the site, finds an open table, books it, and reports back. The moment a language model can do those things — take real actions in the world, observe what happened, and decide what to do next — it stops being a chatbot and becomes an agent.

That is the entire shift in one sentence: agentic AI moves the model from generating answers to pursuing goals. Technically, the model is no longer the product you interact with; it is the reasoning engine sitting inside a larger system that perceives its situation, decides what to do, and acts in a repeating loop until the goal is met or it runs out of options.

This distinction matters because almost every exciting AI product of the last two years is an agent, not a chatbot: coding assistants that fix bugs across a whole repository, research tools that read fifty sources and write a report, support systems that resolve a ticket end to end, and "computer-use" agents that click and type in a real browser on your behalf. Understanding the difference is the foundation for everything else in this course.

Strip away the hype and an agent is a small, understandable structure — not magic. In plain terms, it is a language model that keeps taking actions and looking at the results until a job is done. Stated precisely, an AI agent is:

A system that uses a language model to decide a sequence of actions toward a goal, executing those actions through tools, observing the results, and repeating until the goal is reached or it gives up.

Four ingredients make it work:

1. A model — the reasoning core that decides what to do next.
2. Tools — functions the model can call to affect or sense the world: search the web, run code, query a database, send an email.
3. Memory — a way to carry information across steps, from the current conversation up to long-term knowledge.
4. A loop with a goal — the orchestration that feeds each result back to the model and runs until done.

Take any one away and the magic fades. No tools, and it can only talk. No loop, and it acts once and stops. No memory, and every step forgets the last. No goal, and it has nothing to pursue. Agency is the combination, not any single part.

The fastest way to feel the difference is to put all three next to each other. A scripted automation follows a fixed recipe, a chatbot has a single conversation, and an agent works a problem until it's solved.

Traditional automation is powerful but brittle: a human hard-codes every step, and the moment reality deviates — a button moves, a field is missing — it fails. A chatbot is flexible with language but inert; it answers and waits for you.

An agent combines the language flexibility of a chatbot with the ability to do — and crucially it closes the loop: after each action it looks at what actually happened and chooses the next step accordingly. That feedback loop is precisely why an agent can handle the messy, open-ended tasks that neither a rigid script nor a one-shot chatbot can touch.

"Agentic" is not all-or-nothing. Think of a dial, not an on/off switch: systems sit along a spectrum of how much they decide for themselves. As you turn the dial up, the system needs less hand-holding and makes more choices on its own.

• Assistant — you drive; it responds. (A chat assistant answering questions.)
• Copilot — it suggests and acts within tight bounds, you approve each step. (An IDE autocomplete that proposes edits.)
• Workflow agent — it executes a multi-step task you defined, handling sub-decisions itself. ("Triage these 200 tickets.")
• Autonomous agent — you give a goal; it plans, acts, and adapts over many steps with minimal supervision. ("Find and fix the failing tests in this repo.")

More autonomy means more capability and more risk: the same freedom that lets an agent solve an open-ended task also lets it make a costly mistake unsupervised. That is why most successful real-world systems today deliberately sit in the middle — enough autonomy to be useful, enough human checkpoints to be safe. A recurring theme of this course is choosing the right point on this spectrum for your task, not the most autonomous one.

Agents are an old idea — researchers have chased autonomous software for decades, and most attempts were fragile demos. What changed recently is that three specific capabilities matured at the same time, roughly 2023–2025, and together they pushed agents over the line from "cute prototype" to "ships in production."

1. Reliable tool use. Models learned to emit structured function calls — clean, machine-readable requests like search("competitor pricing") instead of free-form text. That means a program can actually execute the call and trust the format.
2. Long context. Context windows grew from a few thousand tokens to hundreds of thousands. The context window is the model's working memory — the bigger it is, the more plan, history, and retrieved documents an agent can hold in mind at once.
3. Stronger reasoning. Better base models — and dedicated reasoning models that "think" step by step before answering — made the multi-step planning agents depend on far more dependable.

None of these alone creates an agent. Together they crossed a threshold where putting a model in a loop with tools went from a fragile experiment to something companies confidently put in front of users.

Agentic systems are exciting, which makes it tempting to reach for one reflexively. Resist that instinct. Because an agent makes its own decisions across multiple model calls, it inherently adds latency, cost, and unpredictability — three things production systems hate.

If a task is well-defined and repeatable, a plain script or a single model call is cheaper, faster, and more reliable. Use an agent only when the task genuinely needs:

• Open-endedness — the steps aren't known in advance.
• Adaptation — the system must react to what it discovers along the way.
• Tool use across many steps — searching, reading, computing, and acting in sequence.

The mark of a good engineer here is restraint: use the least agentic solution that solves the problem. Start simple — a script, then a single prompt, then a fixed workflow — and add autonomy only when the task genuinely demands it.