AI agents explained: how autonomous software plans, acts, and fails

01 What an AI agent actually is

An AI agent is an AI program that pursues goals rather than simply answering questions. It uses tools and software, takes actions in some environment, and keeps working until the job is done or it runs out of ways to proceed. Wikipedia's article on the topic frames agentic AI in exactly those terms, explicitly distinguishing agents from AI systems that behave like tools awaiting a single instruction.

The classical definition is far older than the current crop of products. In the intelligent-agent literature, an agent is something that perceives its environment and acts autonomously in pursuit of its goals, and the field itself is described as the study and design of intelligent agents. A modern coding assistant that opens files, runs tests, and revises its own work fits that template. The chat-only models of 2023, which could only produce text in response to a prompt, did not.

02 The anatomy of an agent

Strip away the product names and most agents share four parts. The model is the reasoning core: it reads the goal, holds the state of the task, and decides what to do next. Tools are capabilities exposed to the model through function calling, such as web search, code execution, file edits, or API requests. Memory spans the live context window plus external stores, like vector databases and scratch files, that survive beyond a single session.

The fourth part is the orchestration loop that ties the others together: plan, act, observe, repeat. The model drafts a plan, invokes a tool, reads the result, and either continues or revises. None of these components is individually new. What changed is that each of them got good enough at roughly the same time, which is why agents went from demos to deployments.

03 Why agents became viable only now

Researchers demonstrated agent-like systems years before they were dependable, because every ingredient except the model was already waiting. Three shifts closed the gap. Long context windows let a model hold an entire codebase slice or a long research file in working memory instead of squinting at lossy summaries. Standardized function calling replaced fragile prompt hacks with a structured contract the model is actually trained to honor.

The other two shifts are economic and intellectual. Falling inference cost made twenty-step tasks affordable; a loop that burns tens of thousands of tokens per run was absurdly expensive in 2023 and routine by 2025. And base-model reasoning improved to the point where the plan itself is usually sane, so failures now concentrate in execution rather than comprehension.

04 What benchmarks actually measure

SWE-bench Verified is the cleanest window into the jump. It takes 500 real GitHub issues that human reviewers validated as genuinely resolvable, hands each one to an agent, and scores whether the submitted patch actually resolves the issue. In 2023, the best reported system resolved 1.96 percent of the set, which is to say almost nothing worked.

By 2025, reported numbers reached 82.0 percent. Two details in the record matter. First, the progression was not gradual: Claude 2 sat at 1.96 percent, and the generation-to-generation jumps after that were steps of tens of points. Second, the scaffold is part of the system. Claude 3.7 Sonnet scored 63.7 percent raw and 70.3 percent with an agent scaffold wrapped around it, and Sonnet 4.5 reached 77.2 percent raw and 82.0 percent with the scoring arrangement. These bars measure model plus harness, never the raw model alone.

05 Failure modes

The same loop that makes agents useful makes them fragile, because errors compound across steps. If each of 20 steps succeeds with 95 percent reliability, the probability that every step succeeds is 0.95 raised to the 20th power, which works out to roughly 36 percent. The run fails more often than it succeeds even though each individual step looks excellent. Long chains punish anything short of near-perfection.

The catalog of specific failures is remarkably consistent across teams: hallucinated tool arguments, such as a file path that does not exist or a wrong parameter name; infinite retry loops, where an error message fails to change the model's behavior so it repeats the same call; and confidently wrong file edits that look plausible in the diff and fail in the tests. Every burned token is a real cost, and the budget of a typical run skews heavily toward planning, tool calls, and retry-and-repair work rather than the final answer.

06 Deployment reality

Where outcomes are verifiable and actions are sandboxed, agents already work in production. Coding agents can run the test suite and get an objective verdict on their own work. Deep-research tools produce citations a reader can check. Customer-support agents operate inside constrained action spaces with human review on anything irreversible. The common thread is a fast, cheap signal that says whether the agent succeeded.

Open-ended computer use and high-stakes actions remain brittle. An agent clicking through arbitrary graphical interfaces accumulates the compounding error problem with no verification signal to catch it, and nobody seriously hands production databases or payment flows to a model's judgment alone. The pattern that has emerged is simple: agent autonomy scales with verifiability, not with model size.

07 What to watch next

Four developments will shape the next cycle. First, standardized agent evaluation: the field still lacks a shared yardstick that measures full multi-step trajectories rather than single responses, which makes cross-paper comparisons treacherous. Second, guardrails and permissioning: the practical deployments are converging on explicit policies for which actions an agent may take unprompted and which require a human approval step.

Third, agent-to-agent economies, where agents negotiate and transact with other agents instead of only calling tools. Fourth, token-efficiency as a first-class metric: Anthropic reports that Opus 4.5 matches Sonnet 4.5's best SWE-bench score at medium reasoning effort while using 76 percent fewer output tokens. When cost per completed task, not just pass rate, decides deployment, efficiency stops being an optimization detail and becomes the scoreboard.