"AI agent" is one of the most overused phrases in the industry right now — and also one of the most genuinely important shifts in how AI products get built. Here's the difference between marketing language and what an agent actually is, mechanically.
What is an AI agent?
An AI agent is a system built around an LLM that can take actions in the world — not just generate text, but call tools, query APIs, read and write files, or trigger other systems — and then use the results of those actions to decide what to do next. The anchor analogy we teach: a plain LLM is a mouth, an agent is an LLM with hands. It can't just describe what it would do; it can actually go do it.
Agent vs a plain LLM call
A single LLM call is: prompt in, text out. There's no interaction with the outside world, and no ability to check its own work. An agent adds a loop around that call: the model can decide "I need to look something up" or "I need to run a calculation," invoke a tool to do it, see the result, and decide what to do with that new information — possibly calling more tools, possibly asking a follow-up question, before finally responding to the user.
This is the architectural leap between a chatbot and something like an AI assistant that can actually check your calendar, search a live database, or file a support ticket.
How tool calling works
Modern LLM APIs support function calling (also called tool calling): you describe a set of functions available to the model — a name, a description, and the parameters it accepts — and the model can respond by "requesting" one of those functions with specific arguments, instead of (or in addition to) generating plain text.
Your application code is what actually executes the function — the model never runs code itself. It just decides which tool to call and with what arguments, based on the conversation so far. Your code runs the real function (say, a weather API call or a database query), and feeds the result back into the conversation so the model can use it to form its final answer.
The agent loop
A basic agent loop looks like this:
- The model receives the user's request plus a list of available tools
- The model decides: answer directly, or call a tool
- If a tool is called, your code executes it and returns the result to the model
- The model incorporates that result and decides again: answer, or call another tool
- This repeats until the model produces a final answer (or hits a safety limit on how many steps it can take)
In our Generative AI course, students build this loop from scratch in the AI Agents & Tool Calling module — starting with a simple calculator-and-search-tool agent, before combining it with RAG in the capstone AI Career Assistant project.
What "Agentic AI" means
"Agentic AI" describes systems designed around autonomous, multi-step decision-making — agents that plan a sequence of actions toward a goal, rather than responding to a single request. This is where frameworks like LangChain and LangGraph, or multi-agent orchestration patterns, come in: they provide scaffolding for planning, memory, and coordinating multiple specialized agents. Our course covers the underlying mechanics first — tool calling, the agent loop, planning — precisely so that any framework you later adopt is something you understand, not something you're cargo-culting.
A framework doesn't remove the need to understand the agent loop underneath it — it just gives you less control when something goes wrong in production. Learn the mechanics first.
Why agents are hard to make reliable
Agents fail in ways plain LLM calls don't: they can call the wrong tool, get stuck in loops, misuse a tool's arguments, or compound a small early mistake into a completely wrong final answer several steps later. Our production AI module covers the mitigations that matter most in practice — bounding the number of steps, validating tool outputs before feeding them back to the model, and logging every step of the loop so failures are debuggable rather than mysterious.
Session 12 of the course includes a live prompt-injection challenge, where students attack a demo agent before learning how to defend one — a faster way to understand agent reliability limits than reading about them.
Building your first agent
The fastest way to actually understand agents is to build one with a single tool, watch it fail, and fix why. That's exactly how Session 10–11 of our Generative AI course is structured — see the full curriculum, or browse GenAI project ideas if you want to start experimenting on your own first.
Keep learning: Build your own in the AI Career Assistant capstone, or explore the Generative AI course.