The history of AI agents How software learned to pursue goals and act.

Shannon described how a computer could represent a chess position, generate legal moves, evaluate resulting positions, and search selectively when exhaustive analysis was impossible.

The paper separated a goal, an environment model, an action generator, and a decision rule. Those components recur in planning and game-playing agents.

GPS represented a current state, a desired state, differences between them, and operators that might reduce those differences. Its means-ends analysis chose subgoals when an operator could not yet be applied.

It made goal decomposition and operator choice explicit, two ideas that later planning agents would formalize more sharply.

McCarthy proposed a program that would accept declarative statements about its world and use them to infer which actions could achieve a goal.

It drew a clean boundary between knowledge and the reasoning procedure that acts on it, a separation later agent systems repeatedly used.

Shakey used cameras, range sensing, a world model, route finding, and symbolic planning to carry out commands in a specially prepared room environment.

It made the entire agent loop visible in one machine. Perception updated state, a planner chose actions, and the robot executed them in the world.

A* ranked partial paths by the cost already paid plus a heuristic estimate of the cost still remaining, with conditions under which the first solution found is optimal.

The algorithm became a standard planning component for robots, games, logistics, and any agent that must choose a route through known alternatives.

STRIPS described actions through preconditions and changes to a symbolic world state, then searched for an action sequence that made a goal description true.

Its compact action model shaped decades of automated planning and still appears, directly or indirectly, in agent planners and benchmark environments.

HEARSAY-II split speech understanding among independent knowledge sources. Each watched a shared blackboard, posted partial hypotheses, and worked when its expertise became useful.

The architecture showed how many specialized processes could cooperate without one fixed pipeline, a pattern later multi-agent and workflow systems would revisit.

Contract Net organized cooperative problem solving as a negotiation. A manager announced a task, eligible nodes submitted bids, and the manager awarded a contract based on the reported capabilities.

It turned dynamic task allocation into a communication protocol, an enduring idea in multi-agent coordination.

Brooks built robot control from concurrent behavior layers. Newer layers could suppress or redirect lower ones, while sensing and action stayed close enough for real-time response.

Subsumption challenged the view that intelligent action required a complete symbolic model and a central planner before a robot could move.

PRS maintained beliefs about the current world, goals to pursue, a library of procedural plans, and intentions already chosen. It could reconsider execution when new events arrived.

The system joined deliberation with real-time response and became a practical foundation for belief-desire-intention agent architectures.

Bratman argued that intentions are more than current desires. They stabilize future conduct, constrain later choices, and coordinate plans across time and among people.

Agent researchers used that account to distinguish what a system believes, what it wants, and what it has committed to doing.

Rao and Georgeff gave belief, desire, and intention a branching-time logical model, making it possible to state and analyze how rational agents choose and maintain commitments.

BDI moved from an architectural intuition toward a research program with explicit semantics, implementations, and testable design choices.

Q-learning updated the estimated value of taking an action in a state from observed rewards and the best estimated value available next, without requiring the transition rules in advance.

An agent could learn action values directly from interaction, separating control from a hand-written model of how the environment works.

Shoham proposed programs whose state includes beliefs, commitments, capabilities, and decisions, with messages defined in terms of how they alter those states.

The paper treated agents as a distinct software abstraction with persistent state, communication, and commitment.

KQML wrapped content in performatives such as ask, tell, subscribe, and achieve, allowing networked knowledge systems to state the purpose of a message as well as its payload.

It made interoperability among independently built agents a concrete protocol problem, decades before today's agent-protocol boom.

Wooldridge and Jennings organized a scattered literature around autonomy, social ability, reactivity, and proactiveness, then compared deliberative, reactive, and hybrid architectures.

The paper gave researchers a shared technical vocabulary and tied agency to a system's sustained relationship with its environment.

AgentSpeak(L) described agents through beliefs, events, goals, and plans. Events trigger relevant plans, and an agent chooses among applicable plans while maintaining multiple intentions.

It connected BDI theory to a compact programming model that later interpreters and agent languages could implement and extend.

The first official RoboCup competition brought simulated and physical robot teams into a dynamic setting where perception, action, communication, and cooperation all mattered at once.

A common public task let laboratories compare complete multi-agent systems under the same rules.

FIPA's first specification set defined an agent communication language, message structure, and infrastructure services for independently developed agents.

The standards treated interoperability as more than moving bytes. A message also carried a communicative act, sender, receiver, content language, and ontology context.

JADE supplied containers, agent lifecycles, directories, messaging, and debugging tools that implemented FIPA services in a Java runtime.

Researchers and developers could build distributed agent systems without recreating the communication substrate for every experiment.

Stanley completed a 132-mile desert route without a human driver and won a race in which five autonomous vehicles reached the finish, one year after every entrant had failed the first challenge.

The event forced complete systems to combine sensing, terrain interpretation, planning, control, and failure recovery over hours of physical operation.

UCT applied an upper-confidence rule to Monte Carlo tree search, balancing moves that already looked promising against moves whose consequences remained uncertain.

The algorithm made large planning trees more tractable and became a key ingredient in later game-playing agents, including the search used by AlphaGo.

DQN combined Q-learning with a convolutional neural network, replayed stored experience during training, and learned game actions from screen pixels and scores across Atari 2600 titles.

A single learning recipe connected high-dimensional perception to action selection without a separate hand-built vision pipeline for every game.

AlphaGo used policy networks to propose moves, a value network to estimate positions, and Monte Carlo tree search to look ahead. It defeated Lee Sedol four games to one.

The system showed how learned representations and explicit planning could complement each other in a search space once considered too large for conventional game-tree methods.

A3C ran multiple actor-learners in parallel environments. Their varied experience updated a shared network, reducing the correlation problems that destabilized training from one sequential stream.

It made policy-gradient training practical across a broad task set without an experience replay buffer and helped establish actor-critic methods as a standard agent design.

Gym presented environments through a small reset, observe, act, reward loop and gathered classic control, Atari, board-game, and physics tasks behind one interface.

Algorithms could be tested against the same environments with less custom integration, helping reinforcement learning become more reproducible and composable.

Libratus combined a precomputed strategy, real-time subgame solving, and automated analysis of its own strategic weaknesses. It defeated four top specialists over 120,000 hands.

The result showed that planning agents could handle hidden information and strategic deception at a scale where a full game solution was impossible to store.

Instead of writing a reward function, people repeatedly chose which of two short behavior clips better matched the intended goal. A learned reward model then trained the policy.

The work offered a practical route for teaching objectives that are easier to judge than to specify, while introducing a new failure point in the learned reward model itself.

AlphaGo Zero began with the rules and a random policy, generated its own games through self-play, and used one network to predict moves and positions while tree search improved each round of training.

The system removed human game records and hand-crafted game features from AlphaGo's training pipeline, showing how an agent could create a powerful curriculum from competition with itself.

AlphaStar trained a league of diverse agents that played against one another, exploited weaknesses, and generated new opponents. The final system reached Grandmaster level under an interface designed to limit actions and camera access.

League training turned self-play into a population strategy for avoiding cycles and blind spots in a complex, partially observed real-time game.

WebGPT let a GPT-3 model issue search, open, find, and quote actions in a text browser. Human demonstrations and preference comparisons trained it to research questions and attach supporting citations.

The work made retrieval an interactive policy and exposed the model's evidence path for human inspection.

SayCan scored candidate robot skills two ways: a language model estimated how useful each skill was for the instruction, while learned value functions estimated whether the robot could execute it from the current state.

The combination prevented a fluent planner from choosing actions the physical system did not know how to perform and linked high-level language to grounded skills.

ReAct prompted a language model to alternate between written reasoning and actions such as searching a knowledge source or interacting with a text environment, then use each observation in the next step.

The pattern made a language model's tool loop simple to inspect and reproduce, and it became a common template for later LLM agent frameworks.

Toolformer sampled candidate calculator, search, translation, calendar, and question-answering calls inside ordinary text, kept calls that improved token prediction, and fine-tuned on the surviving examples.

The model learned both where a tool might help and how to place its result into generation without a manually labeled tool-use dataset for every call.

Twenty-five language-model characters stored observations in a memory stream, retrieved memories by relevance, recency, and importance, formed higher-level reflections, and generated daily plans in a simulated town.

The project gave developers a concrete architecture for long-running language agents whose later behavior depends on selected past experience as well as the current prompt.

Voyager used GPT-4 to propose exploration goals, write JavaScript skills, inspect execution feedback, repair failed code, and store successful skills for later reuse in Minecraft.

The agent accumulated executable abilities across a long run without changing the language model's weights, making external memory and code a form of continuing adaptation.

SWE-bench paired 2,294 resolved GitHub issues from 12 Python repositories with the repository state before each fix and tests that distinguish a successful patch from a failed one.

Coding systems had to inspect a real codebase, understand an issue, edit several files when needed, and satisfy executable tests. The unit of work was a repository repair, not an isolated function.

OSWorld introduced 369 tasks across Ubuntu, Windows, and macOS applications, with scripts that prepare initial state and execution-based checks that inspect the resulting computer state.

A computer-use agent had to work across applications, visual interfaces, files, and system settings while evaluators checked what it actually changed.

SWE-agent gave a language model compact commands for searching, viewing, and editing repository files, controlled how much code appeared at once, and returned concise feedback after each action.

The paper showed that the agent-computer interface can change coding performance substantially even when the underlying language model stays fixed.

Anthropic released computer use in public beta for Claude 3.5 Sonnet. A developer could send screenshots and tool definitions, execute the model's cursor or keyboard request, then return the new screen for the next turn.

A general model could enter the same visual interface used by people, widening the action surface from named APIs to existing desktop software.

MCP defined a client-server protocol through which servers can advertise tools, resources, and prompts to AI applications, replacing a growing collection of one-off connector formats.

Tool discovery and invocation acquired a shared boundary that different applications and data providers could implement independently.

A2A defined agent cards for capability discovery and a stateful task exchange between client and remote agents, including messages, artifacts, streaming updates, and long-running work.

Agents built by different vendors gained a common way to advertise capabilities and coordinate a task without exposing their internal memory or tools.

Operator began as a research preview powered by a Computer-Using Agent that acted through screenshots and browser controls. In July, ChatGPT agent combined Operator's visual browser with deep research, a restricted terminal, and connectors.

A consumer-facing agent could move between researching, browsing, running code, and acting in connected services inside one task, which widened both the useful action surface and the safety boundary.

Google DeepMind's AI Control Roadmap treats a capable internal agent as a possible insider threat. It organizes defenses around restricting access, monitoring behavior, evaluating control measures, and preparing for systems that may act strategically.

By mid-2026, the frontier question had moved beyond whether an agent could call a tool. Organizations also had to preserve meaningful oversight while agents held credentials, crossed systems, and completed long tasks. An independent index of 30 deployed agents found that public safety and evaluation disclosure remained sparse.