The difference between a chatbot and an agent is the difference between asking someone a question and hiring someone to get a job done.
A chatbot is a tool you talk to. You ask it a question. It answers. You ask another question. Back and forth, a conversation. It's convenient. It's limited.
An agent is a system that reasons, takes action, observes the result, and decides what to do next. You give it a goal — research patent law in three jurisdictions, write a contract, debug why a database query is slow — and it breaks the goal into steps. It uses tools. It reads the output. It adjusts its approach. It works until the goal is complete or escalates to you.
That loop — think, act, observe, decide, repeat — is what separates an agent from a conversation. And it's what makes agents powerful enough to handle tasks that actually require intelligence, not just eloquence.
This module builds the mental model you'll need to design, deploy, and oversee agentic systems.
A law firm has an "AI assistant." It answers questions about case law. It's a chatbot. Partners ask it to look up precedents. It delivers accurate, well-cited answers. It's useful. It hasn't changed anyone's billable hours.
Three cities away, a competitor deployed something different. It's called an agent. When a new case brief lands on an attorney's desk, the agent reads it automatically. It breaks down the legal question into sub-questions. It searches three precedent databases in parallel. It reads the full text of every relevant case. It identifies procedural requirements unique to that jurisdiction. It drafts an outline of a motion. It fact-checks its own citations against the database. It checks local court rules to ensure compliance. It finds an error in the draft — a citation that would actually undermine the argument — and rewrites that section. Then it sends the draft to the attorney with a summary: seven relevant precedents, three procedural concerns, two points where you should review the case law yourself.
The first firm's research process: a lawyer spends three hours on research, two hours drafting the motion outline, one hour checking citations and court rules.
The second firm's research process: the agent runs in one hour. The lawyer spends 45 minutes reviewing and refining.
That's not a better chatbot. That's a different category of tool. Within 18 months, the competitor is handling 40% more routine motions with the same staff. They're winning cases faster. They're bidding lower on commodity work because their labor cost per file is down. And the first firm's managing partner just realized the gap isn't in intelligence — it's in architecture.
The chatbot was a question-answering system. The agent was a task-execution system. Different design. Different outcome.
Every agent, no matter what domain, has the same four components. Learn these and you can analyze any agent system.
This is the language model at the core. It reasons about the task, breaks it into steps, decides which tool to use next, interprets the results. The model doesn't execute — it decides. Claude, GPT-4, Gemini. The thinking engine. Upgrade the model and you upgrade the agent's reasoning; downgrade it and the whole system gets dumber.
The execution layer. Search a database. Write a file. Call an API. Run code. Send an email. Read a PDF. Each tool is a specific action. The model decides which tool to use; the tool executes the decision. No tools means no ability to change the world — just reasoning, no action. The breadth and safety of your tools determine the breadth and safety of your agent.
Everything the agent can recall to make decisions. In-context conversation history from the current session. External databases it can query. Long-term state about past decisions. Vector databases of documents. Real-time data feeds. The more and better memory the agent has, the more sophisticated its decisions can be. Memory is also liability — garbage in, garbage reasoning out.
This is the architecture that chains everything together: think about the task, choose a tool, execute it, read the result, update your understanding, think about what's next, repeat until done or escalate to a human. This loop is what makes an agent different from a chatbot. The loop enables autonomy. It also enables spiraling into bad decisions if the loop isn't constrained properly.
Each of these four components can fail independently. Understand how, and you understand how to build reliable agents — and how to recover when they go wrong.
Agents are not a future technology. They're already deployed, already generating value, already failing in production. You've used them without realizing it.
GitHub Copilot Workspace, Cursor, Devin — these are agents that read a codebase, understand the architecture, propose changes, sometimes execute them automatically. They reason about the full context of a project, not just individual functions. They use tools: file search, code analysis, test runners, git operations. The loop runs while the engineer watches, pauses to ask questions, and provides guidance. This is agentic architecture applied to coding.
Expense processing: an agent reads an expense report, validates it against company policy, flags deviations, approves or escalates, updates the accounting system. Contract review: an agent reads a proposed contract, identifies non-standard terms, compares against a template library, drafts a redline, flags legal risks. Scheduling: an agent reads calendar requests, finds conflicts, proposes alternatives, books rooms. None of these look like what you think of as "AI." All of them are agents — reasoning, acting, observing, adapting.
Literature review agents that search academic databases, read abstracts, synthesize findings, flag contradictions and gaps in the literature — all autonomously. Market analysis agents that monitor news feeds, parse financial data, build trend models, and alert analysts to shifts. These agents work in domains where exhaustiveness matters and human time is expensive. They don't produce final answers; they produce curated, organized intelligence that a human expert turns into insight.
The pattern is consistent: wherever a task requires reasoning plus action plus adaptation, an agent can be deployed. The trick is knowing how to design one safely and how to oversee it once it's running.