What Is an AI Agent? The Definition, the Loop, and the Coding Kind

An AI agent is a software system that takes a goal, perceives its environment, reasons about the next step, acts through tools, and repeats until the goal is met or a stop condition is hit. That loop is the whole definition. A model that answers your question is not an agent; a model that answers it by searching, reading three files, running a test, and revising its own attempt is.

The word gets attached to almost everything right now, so the working test the builder community has settled on is blunt and useful: an agent is a language model in a loop with tools. No loop, no tools, no agent. This page pins the definition down, contrasts it with the things it gets confused with, and then goes where the big explainers do not: the coding agent, which is the version you actually meet when you build software this way.

Agent vs chatbot vs assistant vs bot

The fastest way to hold the definition is by contrast.

The line that matters is the last column. An assistant waits for your next message; an agent decides its own next step. The definitions across Wikipedia, Google Cloud, and the current technical guides all converge on that: autonomy plus tool use plus multi-step pursuit of a goal.

The loop, and the four parts that run it

Every agent, from a research assistant to a repo-fixing coding agent, runs the same cycle: perceive the current state, reason about what to do, act through a tool, observe what happened. MLflow's 2026 guide describes it as the perceive-reason-act-observe loop, and the same loop pattern already appeared here in the agentic workflow explainer, because a workflow is exactly this loop pointed at a goal.

Four components make it real:

1. The model. The reasoning core. Its quality bounds everything downstream.
2. Tools. File access, shell, browser, APIs. Without tools the loop can only think.
3. Memory. What has been tried and what came back, living mostly in the context window, which is why long agent runs degrade as it fills.
4. The harness. The orchestration code that runs the loop, enforces stop conditions, and holds the guardrails. Builders on X increasingly name the harness, not the model, as where agent quality is won and lost.

Textbook taxonomies also sort agents into types, from simple reflex agents up through goal-based and learning agents, a classification Wikipedia keeps well. For day-to-day building the taxonomy matters less than the loop: what you meet in practice is one pattern with different amounts of freedom.

The coding agent, the version builders actually meet

The big explainers cover enterprise agents booking meetings. The agent most readers of this site meet is different: it lives in a repository. A coding agent reads your issue, chooses which files to open, edits several of them, runs the tests, reacts to failures, and hands you a pull request. Same loop, but with a property the general case lacks: a verifiable end state. Tests pass or they do not, and that checkable "observe" step is why coding is where agents got good first.

What separates a coding agent from autocomplete or a chat assistant is scope per instruction. You state the outcome; it manages the steps.

The current coding agents differ mainly in harness design: how they pick context, when they ask permission, how they recover from their own mistakes. That discipline of building software through agents deliberately, with review gates and verifiable steps, has its own name and page: agentic engineering.

A concrete contrast makes it land. Ask a chatbot to fix a failing test and you get a suggestion to paste. Give a coding agent the same goal and it finds the test, reads the code under it, makes the change, reruns the suite, and reports what it did, and the difference between those two experiences is the loop.

What agents still get wrong

The honest section, since the marketing points one way. Agents act, so their failures act too: a wrong tool call does something rather than merely says something. The failure modes builders actually report are consistent: tool hallucination (calling an API that does not exist), loops that wander without converging, and cost blowups, because every iteration re-sends context and token spend scales with steps.

The standing mitigations are equally consistent. Keep human-in-the-loop gates at expensive or irreversible steps, which remains standard practice in 2026. Constrain tools to what the task needs. Prefer tasks with verifiable end states, because an agent that cannot check its own success produces confident motion instead of results.

Reliability reports from computer-use agents follow the same line: strongest on narrow, repeatable workflows, weakest on open-ended ones.

And sometimes the right amount of agent is none. A single prompt beats an agent for anything one model call finishes. A script beats an agent for any fixed sequence. The agent earns its complexity exactly where the path cannot be written down in advance.

How to evaluate an agent tool

Five questions that sort the current tools faster than any feature list:

1. What can it actually touch, and can you narrow that?
2. Where does it pause for approval, and can you move those gates?
3. How does it handle its own failures: retry, ask, or plough on?
4. What does a long session cost, and can you see spend before the invoice?
5. Can you inspect what it did afterwards, step by step?

Tools that answer all five clearly tend to be the ones built by teams who run agents on their own work.

FAQ

What is an AI agent in simple terms? A system that takes a goal and runs a loop: perceive, reason, act through tools, observe, until the goal is met or a stop condition fires.

How is it different from a chatbot? A chatbot answers and waits. An agent keeps state, plans, and acts across many steps without a new prompt for each one.

What are the components? Model, tools, memory, and the harness that runs the loop with guardrails.

What is an AI coding agent? An agent that works in repositories: multi-file edits, test runs, pull requests. The type with a verifiable end state, which is why it works best.

Do agents need human oversight? Yes, at the steps that are expensive to undo. That is placement, not paranoia.

When is an agent the wrong tool? Single-step tasks, fixed sequences, and anything irreversible without guardrails.

The short version: the agent is the loop, the harness decides how good the loop is, and the coding agent is the strongest version of the idea because software gives the loop something real to check itself against. If you are choosing your first one, start from the coding agents hub and judge tools by their gates and their receipts, not their demos.