What Is an AI Agent, Really?

"Agent" has become one of the most overused words in tech. It gets stamped on chatbots, browser extensions, spreadsheet macros, and anything else with a model behind it. That makes it hard to tell what's real, and harder to know what you can actually hand off.

The good news is that the real definition is short and precise. An AI agent is a language model running in a loop, using tools, to reach a goal. That's it. Once you see those three parts, you can look at any product and tell whether it's an agent, what it can and can't do, and why it fails when it fails. This lesson gives you that lens, shows you the difference between chatting with an AI and delegating to one, and explains why agents went from party trick to everyday tool so quickly.

The three parts of every agent#

Strip away the branding and every agent, from Claude Code to a custom support bot, is built from the same three pieces.

A language model on its own can only produce text. Ask it what's in your budget.xlsx and it can only guess, because it can't open the file. Give it a read_file tool and it can ask to open the file, see what's inside, and answer correctly.

A tool is any function the model is allowed to request. The model never runs the tool itself. It writes a structured request like "call read_file with path budget.xlsx", and the surrounding program does the actual work and hands back the result. You'll see exactly how in Tools and Function Calling.

The loop is the part people overlook, and it's the part that makes an agent an agent. One tool call is a feature. A model that can call a tool, look at the result, decide what to do next, and keep going for twenty or two hundred steps is a worker.

Chatbot vs. agent: who is the loop?#

Here's the clearest way to feel the difference. Suppose you want to know which of your blog posts get the most traffic and why.

With a chatbot, the conversation goes like this:

1. You ask the question.
2. It says, "Please paste your analytics data."
3. You export a CSV, open it, copy it, paste it.
4. It answers, but notices some rows are missing referrer data and asks you for that too.
5. You go back, find it, paste it.
6. It gives you a better answer, which you then copy into a doc.

Notice what happened. You were the loop. You fetched data, ran the steps, carried results back and forth, and decided when it was finished. The AI did the thinking, but you did all the doing.

With an agent that has access to your analytics export and your blog folder, you write one message:

Look at analytics/2026-q3.csv and the posts in /blog. Find the five posts
with the most traffic, figure out what they have in common (topic, length,
headline style, where the traffic came from), and write your findings to
traffic-report.md with a short list of recommendations. Note any data
quality problems you find.

The agent then opens the CSV, notices the missing referrer data on its own, opens the blog posts to compare them, maybe writes a small script to compute averages, drafts the report, re-reads it, and tells you it's done. Same intelligence; completely different experience. The agent is the loop.

That last row is the shift this whole course is about. Working with agents is less like using software and more like managing a capable, fast, occasionally overconfident colleague.

What happens inside the loop#

Every agent cycles through the same three beats, over and over:

1. Think. The model reads everything so far (your request, its previous steps, what the tools returned) and decides on the next move.
2. Act. It requests a tool: run this command, open that file, search for this phrase.
3. Observe. The tool's result is added to what the model can see, and the cycle starts again.

The loop ends when the model decides the goal is met and replies with a final answer instead of another tool request, or when it hits a limit you set, such as a maximum number of steps.

A compressed version of a real coding agent run looks like this:

You:      The signup form accepts emails without an @. Fix it.
 
Think:    I need to find where the form validates emails.
Act:      search files for "email"
Observe:  src/signup.ts line 42: if (email.length > 0) ...
 
Think:    That only checks the email isn't empty. I'll tighten it.
Act:      edit src/signup.ts
Observe:  file updated
 
Think:    I should confirm I didn't break anything.
Act:      run the test suite
Observe:  1 test failed: "accepts plus-addressed emails"
 
Think:    My check rejects valid addresses like a+b@x.com. Loosen it.
Act:      edit src/signup.ts
Observe:  file updated
Act:      run the test suite
Observe:  all 48 tests passed
 
Agent:    Fixed. The form now requires an @ and a domain. I also kept
          plus-addressed emails working, which a test caught.

Look at what made that good: the agent checked its own work and recovered from its own mistake without you stepping in. That's the payoff of the loop. Lesson The Agent Loop traces a longer run in detail, including where loops go wrong.

Why agents suddenly got useful#

The idea of an AI agent is decades old. People have been wiring language models to tools since the first capable models appeared, and for a long time the results were unreliable: agents wandered off task, repeated themselves, or confidently declared victory after doing nothing. A few things changed.

Models got good at using tools#

Newer models are specifically trained to work in loops: to choose the right tool, read its output carefully, notice errors, and try something else. Earlier models could call a tool; current ones can sustain a long task without losing the thread. This is the single biggest reason agents work now.

Models can hold much more in view#

A model's context window is the amount of text it can see at once, its working memory. Windows have grown from a few pages to the equivalent of several books, which means an agent can keep your instructions, the files it has read, and its own progress in view across a long task. You'll learn the trade-offs in Context Windows, Tokens, and Cost.

Coding proved the concept#

Software turned out to be the perfect training ground. Code has instant, objective feedback: it runs or it doesn't, the tests pass or they fail. That feedback lets an agent verify its own work, which is exactly what you saw in the trace above. Coding agents like Claude Code, OpenAI Codex, Cursor, and GitHub Copilot became the first agents that large numbers of people used every day, and the lessons learned there are spreading to research, data analysis, and office work.

Connecting tools became standard#

Giving an agent a new ability used to mean custom integration work for each app. The Model Context Protocol (MCP) is an open standard that lets any agent plug into any tool server, so an agent that can talk to your calendar, your database, or your design files is now often a configuration change rather than a project. Module 4 covers MCP in depth.

What agents are good and bad at today#

Agents are not magic, and knowing their shape saves you hours of frustration.

Agents tend to do well when:

• The goal is clear and you can describe what "done" looks like.
• They can check their own work (tests, a calculation, a file they can re-read).
• The task is multi-step but each step is something a competent person could do at a computer.
• Mistakes are cheap to spot and undo.

Agents tend to struggle when:

• The request is vague ("make the website better") and success is a matter of taste they can't see.
• Key information lives only in your head, and you didn't write it down.
• There's no way to verify the result, so errors pass silently.
• One wrong action is costly and hard to reverse, like sending an email to a client or deleting data.

Most of those weaknesses aren't about intelligence. They're about context and verification, which are things you control. That's why the skills in this course pay off so quickly.

A quick test for spotting real agents#

When you meet a new AI product, ask three questions:

1. What model is inside? That sets the ceiling on reasoning quality.
2. What tools does it have? That defines what it can actually touch in the world, and what it could break.
3. Who runs the loop? If you have to copy results back and forth, it's an assistant. If it takes multiple steps on its own and decides when it's done, it's an agent.

These questions cut through marketing fast. A "research agent" that can't browse the web is a writer. A "coding agent" that can't run your tests is guessing. And a product with powerful tools but no limits on what it can do with them deserves some caution.