AI Agents Explained

What separates an agent from a chatbot

A chatbot generates text. An agent generates text and takes actions — calling functions, querying APIs, running code, reading files — then observes the result and decides what to do next. The defining feature is the loop:

think → act → observe → think → act → ...

The minimum viable agent

1. An LLM
2. A set of tools (functions the model can call) with JSON schemas describing each
3. A loop that:
   • Sends the conversation + tool list to the model
   • Parses tool calls from the response
   • Executes them
   • Feeds the results back as the next message
4. A stop condition (final answer, max iterations, or budget exceeded)

That's the whole pattern. Frameworks like LangGraph, the OpenAI Agents SDK, and Anthropic's Claude tool-use loop are all variations on this.

Tool design is the actual hard part

A good tool is:

• Narrow — one verb, one job
• Idempotent when possible
• Self-describing — clear name, clear schema, helpful error messages
• Safe — destructive actions should require explicit confirmation

Bad tools (vague names like do_stuff, overlapping responsibilities, silent failures) are the #1 reason agents get stuck.

Example: a good tool vs a bad tool

// Bad
search(query: string) -> Anything

// Good
search_docs(query: string, max_results?: number) -> { title, url, snippet }[]

The good version is narrow, typed, and self-describing. The agent can use it correctly on the first try.

Where agents shine

• Multi-step research — search → read → cross-reference → summarize.
• Coding tasks — read files → edit → run tests → iterate.
• Workflow automation — fetch data → transform → write to system of record.
• Open-ended exploration — when you don't know the steps in advance.

Where agents fail

• Long horizons — error compounds; 95% step accuracy over 20 steps is ~36% success.
• Ambiguous goals — without a crisp definition of done, they wander.
• Tasks with hidden state — anything depending on context they can't observe.

Practical tips

• Start with one tool, not ten. Add tools only when the agent demonstrably needs them.
• Log every tool call and result — debugging an agent without traces is impossible.
• Set a hard step cap. Loop runaway is a real failure mode.
• Give the model explicit permission to ask the user for clarification instead of guessing.
• Build an eval set of 20 representative tasks. Re-run it on every change.

Cost realities

A 20-step agent run on Claude Sonnet, with each step using ~10K tokens of context, costs roughly $0.50–$2 depending on output length. Multiply by your iteration count when evaluating economic viability.

The state of the art (2026)

Agents that succeed at bounded tasks reliably — not general-purpose autonomous workers. Design for that and you'll ship something that works.