AI Agents — What They Are, How They Differ, and How to Use Them

Foundations

What is an AI agent?

The simplest way I can put it: an AI agent is software that can look at a situation, figure out what needs doing, go do it, and adjust if things don't work out. It doesn't wait for you to hold its hand through every step.

I like to think of it this way — a chatbot is like texting a knowledgeable friend. You ask, they answer. An agent is more like hiring a freelancer. You describe the end goal, and they go figure out the steps, pick the tools, run into problems, course-correct, and come back with the finished thing.

That "going off and doing stuff on its own" part is what separates agents from everything else in the AI space right now.

The core difference

Chatbots are reactive — they sit there until you type something. Agents are proactive — give them a goal and they'll break it into pieces, pick up tools, try stuff, fail, try something else, and keep going until it's done or they're stuck.

Architecture

What's inside an agent

Strip away the marketing and every agent I've seen is built from four pieces. The framework doesn't matter — LangChain, CrewAI, custom code — same building blocks:

Core

LLM (the brain)

This is the reasoning engine. It reads context, thinks about what to do next, and decides which tool to reach for. Without a good LLM, the rest falls apart.

Interface

Tools

Things the agent can actually do — search the web, run code, hit an API, read a file, query a database. An agent without tools is just a chatbot with extra steps.

State

Memory

What it remembers from earlier in the conversation (short-term) and what it stores persistently across sessions (long-term). Without memory, agents repeat mistakes.

Logic

Planning

How it breaks a big goal into smaller steps, figures out the order, and decides when to bail on an approach that isn't working. This is the hardest piece to get right.

What makes it click is the loop. The agent looks at where things stand, decides on an action, does it, looks at what happened, and decides again. It keeps cycling until the job's done or it realises it's stuck. That loop is the whole game.

Comparison

Agents vs. chatbots vs. copilots vs. automation

These terms get thrown around interchangeably, which drives me crazy. They're genuinely different things. Here's how I think about the distinctions:

Dimension	Chatbot	Copilot	Automation / RPA	AI Agent
Autonomy	Zero — sits and waits for you	Low — suggests stuff, you pick	High — but only follows scripts	High — figures things out on the fly
Planning	One question at a time	Contextual hints	Pre-built decision trees	Creates its own multi-step plans
Tool use	None	A few (IDE, docs)	Whatever you scripted	Picks tools dynamically based on need
When things break	"Can you rephrase that?"	Shows other options	Crashes or retries blindly	Tries a completely different approach
Memory	Current session only	Session + some project context	None — starts fresh every time	Remembers across conversations
Think of it like	FAQ kiosk	GitHub Copilot	Zapier / UiPath workflow	Devin, AutoGPT, Kiro

It's a spectrum

Honestly, these categories bleed into each other. Copilot with a browser tool? That's basically a lightweight agent. The real line in the sand: can it plan and execute a multi-step task without asking permission at every turn? If yes, it's an agent.

Taxonomy

Types of agents I've seen in practice

There's a lot of academic taxonomy out there. In practice, I've seen four patterns that actually get used:

Workhorse

ReAct Agent

Think-act-observe, one step at a time. Dead simple, easy to debug, handles 80% of use cases. This is where you should start.

Structured

Plan-and-Execute

Makes a full plan upfront, then works through it. Better for tasks where you know the shape of the work ahead of time — like "migrate this codebase" or "write a report with 5 sections."

Team-based

Multi-Agent

Different agents handling different roles — one does research, another writes, a third fact-checks. Cool in theory, often over-engineered in practice. Use only when one agent genuinely can't hold all the context.

Experimental

Self-Improving

Evaluates its own output and iterates. Powerful but risky — I've seen these spiral into weird loops. Needs strong guardrails and clear stopping conditions.

Day-to-day

How I use agents in my personal life

These aren't hypothetical — these are things I've actually set up or used regularly:

Personal

Deep research

When I need to understand a new topic — say, comparing health insurance plans or understanding a new investment strategy — I point an agent at it. It reads 15-20 sources, pulls out the relevant bits, and gives me a structured summary. Saves me entire evenings of tab-hopping.

Personal

Trip planning

I describe what I'm after — "4 days in Lisbon, good food, not touristy, walking distance between things, budget around €120/night" — and let it build the itinerary. It checks actual availability, reads recent reviews, and I just iterate: "swap day 2, I don't like museums." Way better than doing it manually.

Personal

Email triage

I get too much email. An agent scans my inbox, flags what actually needs my attention, drafts replies for routine stuff in my voice, and nudges me on threads I've left hanging. Not perfect yet, but it cuts my email time in half.

Personal

Learning new things

I told an agent "teach me Rust, I know Python well, give me a project-based path." It built a curriculum, found exercises, explained concepts in Python-to-Rust comparisons, and quizzed me. Adjusted when I said "this is too easy" or "I'm lost here."

At work

Professional use cases I've seen work

In my work and across teams I've talked to, these are the agent applications that actually deliver value (not just demos):

Engineering

Code implementation

Give an agent a spec or a ticket, and it reads the codebase, writes the implementation, runs the tests, fixes what breaks, and opens a PR. I use this daily for well-scoped tasks. It's not replacing senior engineers, but it's an incredible accelerator for defined work.

Operations

Incident investigation

Alert fires at 2am. Agent pulls logs, checks recent deploys, correlates the timeline, and tells the on-call "this looks like the config change from PR #847, rolled out 40 minutes before the spike." Doesn't fix it automatically — but gets you to root cause in minutes instead of an hour.

Data

Ad-hoc analysis

"How many users churned last month who had signed up through the referral campaign?" The agent writes the SQL, runs it, notices the numbers look weird, checks for a data pipeline delay, adjusts the query, and gives you the real answer with caveats noted.

Sales

Prospect research

Before a call, an agent digs through the prospect's LinkedIn, recent company news, job postings (what they're hiring for tells you what they need), and competitor moves. Shows up to the meeting actually informed instead of winging it.

Security

Alert triage

Security teams drown in alerts. An agent takes each one, enriches the indicators, cross-checks threat intel, looks at what's normal for that system, and says "this is noise" or "this is real, here's the blast radius and here's what to contain first." Massive time-saver for SOC teams.

Reality check

Where agents still fall short

I'm bullish on agents, but I'm not going to pretend they're flawless. Here's where I still hit walls:

They make stuff up

The LLM underneath can hallucinate, and when an agent acts on a hallucination, it compounds. A chatbot says something wrong — fine, you notice. An agent confidently calls the wrong API or writes to the wrong database based on bad reasoning. Stakes are higher.

They're expensive

A single agent task might take 20-50 LLM calls. That adds up fast. I've had agent runs cost $2-5 for a single complex task. You need to think about where agent-level autonomy is worth the token spend versus just doing it yourself.

They get stuck

Agents can loop, pick the wrong tool three times in a row, or go down a rabbit hole that wastes 10 minutes of compute. The more freedom you give them, the more creative the failures get. Good guardrails and timeouts matter.

What I'd recommend

Start small. Pick a task that's well-defined, low-risk, and annoying to do manually. Let the agent handle that. Once you trust it there, give it something slightly bigger. The teams I've seen fail with agents all made the same mistake: they went straight to "automate everything" before they understood the failure modes.

AI Agents — what they are, how they differ, and how to use them

What is an AI agent?

What's inside an agent

LLM (the brain)

Tools

Memory

Planning

Agents vs. chatbots vs. copilots vs. automation

Types of agents I've seen in practice

ReAct Agent

Plan-and-Execute

Multi-Agent

Self-Improving

How I use agents in my personal life

Deep research

Trip planning

Email triage

Learning new things

Professional use cases I've seen work

Code implementation

Incident investigation

Ad-hoc analysis

Prospect research

Alert triage

Where agents still fall short