What are AI agents, actually

An AI agent is a model that acts. Not chats - acts. It takes a goal, plans steps, uses tools, checks its own output, and keeps going until the goal is met or it hits a wall. The chatbot answers. The agent books the flight, files the report, runs the test suite, and remembers what it did.

That is the one-line version. The honest version requires unpacking what "acts" means, because half of what gets marketed as agentic is just a chatbot with the word agent stapled on.

The three capabilities that make an agent

Tools. The model can call things: search, code execution, APIs, a browser, a file system. Without tools, it can only talk about the task instead of doing it.

Loops. The agent runs plan, act, observe, adjust - repeatedly. A single-shot answer is not agency. The loop is where adaptation lives: the page failed to load, the test failed, the price changed, and the agent recalculates.

State. Memory that survives across steps, sessions, or machines. An agent that re-asks who you are every turn is a chatbot wearing a costume.

Everything called an agent in 2026 sits somewhere on these three axes, and the honest way to evaluate any product is to ask which axis it is weakest on.

Agent versus chatbot versus workflow

A chatbot responds. You ask, it answers, the interaction ends. A workflow automates: fixed steps, fixed order, no decisions. An agent decides: given a goal, it chooses steps, sequences them itself, and handles surprises in between.

The practical spectrum: chatbot answers questions, workflow executes recipes, agent pursues goals. Most valuable 2026 deployments are workflows with one or two decision points - agent-shaped enough to handle messy input, constrained enough to stay reliable. That is not a failure of ambition. That is engineering taste.

	Bot	Assistant	Agent
Decides	No - fixed rules	Recommends, you decide	Yes - acts on the goal
Tools	None or scripted	Limited, per request	Full - calls them itself
Memory	None	Session at best	Persistent across steps
Handles surprise	Breaks	Apologizes	Replans
Example	Spam filter	Autocomplete	Fixes a failing test suite and opens the PR

A worked example: one agent, one task

Goal: the checkout test suite is failing on CI. A human gave the agent that single sentence and went to lunch.

Observe. The agent pulls the CI log, runs the suite locally, and reproduces the failure on the first try. Plan. It reads the test, reads the code under test, and forms a hypothesis: a race condition between the cart service and the inventory lock. Act. It adds a failing test that isolates the race, then fixes the ordering in the service. Check. Tests run green locally, so it pushes a branch and opens a pull request with the diff, the reasoning, and the new test named after the bug.

Four loop iterations, zero human intervention, one reviewable checkpoint. That trace is what "acts" means: not a smarter reply, but a closed loop between doing something and finding out if it worked. Every agent product on the market is a bet on how far that loop can be trusted - and the honest 2026 answer is: far, on checkable tasks, with a human at the commit boundary.

What agents reliably do today

Code. Writing, reviewing, testing, and refactoring code is the flagship. Code has checkable ground truth - it compiles or it doesn't, tests pass or fail - which is exactly what agents need to self-correct.

Research and monitoring. Agents that gather, filter, and summarize changing information have become ordinary infrastructure: tracking news, watching prices, digesting documents.

Operations support. Scheduling, drafting, data entry, customer triage - narrow, supervised, high-volume tasks. Research from 2026 shows agents learn procedures they are shown far better than rules they are told, which is why workflow-embedded agents succeed and free-range knowledge agents disappoint.

Where they fail

Context drift. Long tasks erode: the agent forgets earlier constraints, or its own instructions. The canonical case study: an agent that recommended firing an employee while forgetting the handbook it had itself written - humans executed the firing after review.

Confident wrong turns. Agents fail forward - executing plausible mistakes with full conviction. The failure looks like competence until the result arrives.

Misaligned incentives. When agents are given targets without judgment - purchases, trades, terminations - tiny framing shifts swing their decisions. The human holds the receipt.

The mitigation is always the same shape: narrow scope, checkpoints, human approval at irreversible steps, and logging you can audit. Boring discipline is the product.

Where this goes

The trajectory is visible in the plumbing: persistent agents that keep working until stopped, memory that spans devices, embedded browsers, spending authority. Each integration removes one more approval step between intention and action. That is either the promise or the risk, and it is the same fact read two ways.

The practical stance for anyone building or buying: evaluate agents like junior hires with perfect recall, infinite patience, and no shame. Capable, tireless, occasionally wildly wrong - and best deployed where their work is checkable and their mistakes are reversible.