The History of AI Agents

The history of AI agents runs from the classic agent concept of AI research (a system that perceives its environment and responds to it with actions), through the ReAct pattern (2022), which combines reasoning and acting in the same LLM loop, to today's frontier LLM agents. Open standards such as MCP (2024) and A2A (2025) connect agents to tools and to each other.

Timeline of AI agents from 1966 to 2025

• 1966 to 1972, Shakey: SRI builds Shakey, the first mobile robot that perceives its surroundings and reasons about them. It plans routes and pushes simple objects around.
• 1995, the textbook definition: Stuart Russell and Peter Norvig publish Artificial Intelligence: A Modern Approach. The preface to the first edition makes the intelligent agent the unifying theme of the book: a system that receives percepts from its environment and performs actions.
• October 2022, ReAct: Shunyu Yao and colleagues publish ReAct. Reasoning and acting merge in the same LLM loop, and the perceive-reason-act-observe pattern becomes the blueprint for modern agents.
• March 2023, AutoGPT: The open-source project AutoGPT breaks a given goal down into subtasks on its own and works through them with tools such as web browsing and file access.
• June 2023, function calling: OpenAI adds function calling to its API. Models can now generate structured calls to external functions.
• October 2024, computer use: Anthropic introduces computer use: in a public beta, the upgraded Claude 3.5 Sonnet operates a computer, reads the screen, moves the cursor, clicks, and types.
• November 2024, MCP: Anthropic releases the Model Context Protocol as an open standard for the connection between agent and tool.
• April and June 2025, A2A: Google introduces the Agent2Agent protocol, and in June the Linux Foundation takes it over.
• December 2025, Agentic AI Foundation: Anthropic donates MCP to the newly founded Agentic AI Foundation under the umbrella of the Linux Foundation. Its co-founders are Anthropic, Block, and OpenAI.

The classic agent concept: perception and action

The concept of the agent is considerably older than today's LLM wave. In classic AI, an agent is a system that perceives its environment and responds to it with actions in order to pursue a goal. The simplest form is the reflex agent: rule-based, reactive, without a real model of the world. In today's maturity classification, this corresponds to level L1 (reflex), for example an FAQ bot or a thermostat.

These early agents already had two of the four properties of modern AI agents in rudimentary form: perception of the environment and goal-oriented action. What was missing was a capable reasoning core that could plan in multiple steps and select tools dynamically. Large language models close exactly this gap.

The turning point: ReAct (2022)

The conceptual break came with the ReAct pattern (Yao et al. 2022, arXiv:2210.03629). ReAct stands for reasoning and acting in the same LLM loop: the model interleaves its reasoning about a task directly with actions, such as tool calls, and observes the results before it plans the next step.

This creates the reasoning loop that still forms the core of an agent today: Perceive → Reason → Act → Observe, repeated iteratively until the goal is reached or the run is aborted. ReAct provided the link between the old agent concept (perception-action) and the new world of language models. Only now were all four mandatory properties of an AI agent in place: LLM-driven control, multi-step planning, tool use, and goal-oriented autonomy within guardrails.

Classifying agents today: five maturity levels

The following maturity model classifies today's systems by their degree of autonomy. It is a classification, not a timeline: reflex agents at level L1 existed long before ReAct.

The decisive leap lies between L3 and L4. In a workflow agent, the path is defined in advance; the LLM only fills gaps in a deterministic pipeline. An autonomous agent (L4), by contrast, decides for itself which tools it uses in which order and adjusts its plan iteratively. This is exactly where an agent pays off: when the solution path cannot be planned in advance.

A concrete example of L4 is a coding agent like Claude Code. It receives a goal (such as fixing a bug), reads the relevant files on its own, runs tests, observes the results, and decides on that basis which file to change next. The order of the steps is not written in any script; it emerges in the loop. That is the practical difference between a classic workflow and a true agent.

Frontier LLMs as the new agent core

With the more recent generation of frontier LLMs, the reasoning loop became reliable enough for production tasks. Function calling and computer use brought tool use directly into the model providers' APIs. The article on AI agent components explains which five components make up an agent today.

You don't need to train your own model to build an agent: API-based LLMs provide the reasoning core, and the agent logic lives in the layer above it.

2024 and 2025: standardization with MCP and A2A

Until MCP was released in November 2024, every tool integration was largely proprietary: each new data source needed its own integration. In 2025 came broad adoption, A2A, and the transfer of both protocols to the Linux Foundation. Standardization covers two connections: agent to tool and agent to agent.

MCP (Model Context Protocol) standardizes the connection between agent and tool. The specification is at version 2025-11-25; in December 2025, MCP was handed over to the Agentic AI Foundation under the umbrella of the Linux Foundation. More than 10,000 MCP servers now exist. MCP thus answers the question of how an agent accesses external tools in a vendor-neutral way.

A2A (Agent-to-Agent) standardizes the connection between agents and thereby forms the technical foundation for multi-agent systems (L5). A2A has been with the Linux Foundation since June 2025 and is backed by more than 150 organizations. This makes the coordination of several specialized agents, such as an orchestrator plus domain agents, interoperable across vendor boundaries.

These two protocols mark the transition from isolated individual agents to an open ecosystem.

Where we stand today: hype meets reality

For now, the historical arc ends in a phase of disillusionment and consolidation. Adoption is clearly rising, but maturity in production remains low.

According to McKinsey State of AI 2025, only 23 percent of companies are scaling at least one agentic use case, and another 39 percent are experimenting; in no business function does the share of scaled use cases exceed 10 percent. Gartner expects (as of June 2025) that over 40 percent of agentic AI projects will be canceled by the end of 2027. This goes hand in hand with agent washing: according to Gartner, only about 130 vendors have genuine agent capabilities.

The lesson from this recent history is pragmatic: the use case decides, the framework is secondary. An agent pays off where the solution path cannot be planned in advance; everywhere else, a workflow or classic RPA is cheaper and more reliable. Open standards such as MCP and A2A also reduce dependence on individual vendors and make architectures more future-proof.