What Is an AI Agent

AI Agents vs Chatbots: The Key Difference

A chatbot responds to your message with text. An AI agent takes actions in the real world. That's the fundamental distinction.

When you ask ChatGPT "how do I fix this bug?" and it explains the solution, that's a chatbot. When you tell Claude Code "fix the auth bug in my Express server" and it reads your files, identifies the issue, edits the code, and runs your test suite to verify the fix — that's an agent.

The difference isn't just about capability. It's about autonomy. A chatbot waits for your input, generates a response, and stops. An agent plans a sequence of actions, executes them, observes the results, and decides what to do next — potentially without any further input from you.

The Four Components of an AI Agent

Every AI agent, whether it's a coding assistant or a customer service bot, has four core components:

• Perception — How the agent gathers information. For a coding agent, this means reading files, viewing directory structures, and parsing error messages. For a chatbot, perception is limited to the text you type.
• Reasoning — How the agent decides what to do. This is the LLM itself — it processes the context, plans a course of action, and determines which tools to call. Better models reason more effectively but cost more per token.
• Action — What the agent can actually do. This is defined by the tools available: read file, write file, run terminal command, search the web, make API calls. More tools means more capability, but also more potential for things to go wrong.
• Memory — What the agent remembers. This includes the conversation context (what it's done so far in this session) and potentially long-term memory (project structure, conventions, past decisions). Memory is directly tied to context window and token costs.

A chatbot has only perception (your message) and reasoning (the LLM). It has no tools for action and limited memory. An agent adds the action and memory layers, which is what makes it powerful — and more expensive.

Examples of AI Agents

The AI agent landscape has grown fast. Here are some of the most well-known coding agents:

• Claude Code — Anthropic's CLI agent. It reads your codebase, edits files, runs commands, and manages git. High autonomy, uses Claude models natively.
• Cursor Agent mode — An AI-native IDE with an agent mode that can make multi-file edits, run terminal commands, and iterate on code. Built on VS Code.
• Devin — Cognition's autonomous software engineer. It can plan entire features, write code, debug, and even deploy. High autonomy with minimal human oversight.
• OpenHands — An open-source coding agent (formerly OpenDevin) that can write code, run commands, and browse the web. Self-hosted and customizable.

These agents differ in how much autonomy they're given and how much human oversight they require. Claude Code typically works best with a human directing it task by task. Devin is designed to handle entire features with minimal supervision. More autonomy means more tokens consumed — and higher costs.

How Agent Autonomy Affects Costs

The autonomy level of an AI agent is the single biggest factor in how much it costs to run. Here's why:

A chatbot response costs $0.01. An assisted agent task costs $0.05-$0.15. A fully autonomous agent task costs $0.20-$0.50 or more — and potentially much more when you account for context accumulation, as we explored in our post on context windows and costs. These aren't trivial differences — they add up fast across a project.

Why More Autonomy = More Tokens

• More turns — An autonomous agent makes multiple attempts, reads more files, and runs more commands. Each turn adds to the context and costs input + output tokens.
• More tool calls — Every time the agent reads a file or runs a command, that output gets added to the conversation context. It gets re-processed on every subsequent turn.
• Error recovery — Autonomous agents fix their own mistakes. That's great for productivity, but each fix attempt is additional turns and tokens.
• Context growth — The longer an agent runs, the more context it accumulates, and the more expensive each turn becomes (as we covered in our post on context windows and costs).

AI agents are powerful because they can take action. But every action has a cost — literally. Understanding the relationship between autonomy and token consumption is essential for using agents effectively without burning through your budget.