The History of Agentic AI: Symbolic AI to LLM Agents

I sometimes hear people talk about agentic AI as if it were invented in 2023 with the release of AutoGPT. As someone who started reading AI textbooks in the 1990s, I find this framing both endearing and inaccurate. Agents have been a central idea in artificial intelligence since the 1950s. What changed in 2023 was not the invention of agents but a step change in the capability of the underlying models.

In this article I want to walk through the history of agentic AI properly. I will trace the line from the 1956 Dartmouth workshop through symbolic AI, BDI architectures, reinforcement learning, the transformer revolution, ReAct, AutoGPT, and into the present multi-agent era. Along the way I will highlight the papers and ideas that I think still matter today, and I will draw lessons from earlier waves that builders can apply now.

Understanding the history is more than nostalgia. The challenges that broke previous waves of agent research are still with us. The frame problem, the brittleness of symbolic reasoning, the credit assignment problem in RL, and the difficulty of evaluating open-ended behaviour all show up in modern LLM agents. Knowing how earlier researchers tried and failed to solve these problems is a shortcut to avoiding the same mistakes.

The Dartmouth Summer Research Project on Artificial Intelligence ran for eight weeks in the summer of 1956. The organisers included John McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon. The proposal that secured funding contains the first known use of the term artificial intelligence, and it laid out an agenda that included problem solving, reasoning, and language understanding.

The early researchers thought in terms of programs that could solve specific problems. Allen Newell and Herbert Simon built the Logic Theorist in 1956, which could prove theorems from Whitehead and Russell’s Principia Mathematica. By 1959 they had the General Problem Solver, which used means-end analysis to plan sequences of actions toward a goal. These early systems are recognisably agentic in structure. They have goals, they reason about actions, and they execute plans.

The optimism of the era was striking. Researchers genuinely expected human-level machine intelligence within a generation. The Dartmouth proposal said a significant advance could be made if a carefully selected group worked on it for a summer. That prediction was off by several decades, but the ideas it generated have been productive ever since.

What is sometimes forgotten is how much modern agentic AI inherits from this period. The notion of an agent as a goal-directed entity that reasons about actions is straight out of GPS. The structure of planning, acting, observing, and revising is older than any of us reading this.

The 1960s and 1970s saw the development of symbolic AI as the dominant paradigm. Programs reasoned over explicit representations of knowledge encoded as logical formulas, frames, or production rules. SHRDLU, built by Terry Winograd in 1970, could discuss a simple blocks world in natural language and execute instructions in that world. Mycin, developed in the early 1970s at Stanford, diagnosed bacterial infections using rule-based expert reasoning.

Expert systems became the commercial face of AI in the 1980s. Companies built systems for credit scoring, medical diagnosis, and equipment configuration. The systems worked within narrow domains because their knowledge was hand-crafted. Outside those domains, they failed in dramatic and obvious ways. This brittleness was a defining limitation of the symbolic era.

The lesson I draw is that hand-crafted knowledge does not scale. Even with thousands of rules and decades of refinement, expert systems could not match general human reasoning. When the modern LLM era began, the contrast was stark. A trained model with billions of parameters could discuss almost anything, while a hand-built expert system was still trapped in its domain.

But symbolic AI also produced ideas that we still use. The concept of a knowledge base, the structure of inference rules, and the architecture of a reasoning engine are all alive in modern agent design. Retrieval-augmented generation is in some ways a soft version of the symbolic AI knowledge base.

The first AI winter hit in the mid 1980s when expert systems failed to deliver on commercial promises. Funding for AI research dropped sharply. The grand vision of human-level machine intelligence seemed further away than it had a decade earlier.

What survived the winter was a refocused research community that took the limitations seriously. Out of this period came a renewed interest in agents as a unifying concept. Researchers like Stuart Russell and Peter Norvig codified the agent paradigm in their 1995 textbook, defining an agent as anything that perceives its environment through sensors and acts upon it through effectors.

The agent framing was useful because it forced a clear separation between the agent and its environment. Earlier AI research often blurred this line. An agent paradigm made it possible to talk about rationality, partial observability, and learning in precise terms.

This period also produced the first serious work on multi-agent systems and distributed AI. Researchers studied how agents could cooperate, compete, and negotiate. The vocabulary we use for modern multi-agent LLM systems, including supervisors, peers, and protocols, comes from this era.

The 1990s saw the rise of the Belief Desire Intention, or BDI, agent architecture. Developed by Michael Bratman and refined by computer scientists including Michael Georgeff, BDI agents have explicit representations of their beliefs about the world, their desires for what should happen, and their intentions for what to do next.

BDI was influential because it gave agent designers a clean mental model. An agent has beliefs that it updates from observations. It has desires that come from its goals. It commits to intentions that drive action. The cycle of belief revision, deliberation, and action is recognisable in modern agent design.

The 1990s also produced the FIPA agent communication standards, the JADE platform, and a body of work on agent ontologies. Much of this work was theoretical, but the patterns are still useful. The protocols for agent to agent messaging that are emerging now in the LLM agent world rhyme with FIPA work from thirty years ago.

Every generation of AI rediscovers the agent paradigm with new tools. The structure stays the same, the implementation changes.

The limitation of 1990s agents was the same as before. The reasoning was symbolic, the knowledge was hand-crafted, and the systems were brittle. The infrastructure was solid but the engine was weak.

The 2000s saw reinforcement learning move from a theoretical curiosity to a practical technique. Richard Sutton and Andrew Barto’s textbook, first published in 1998, laid the foundation. By the mid 2000s, RL was being applied to robotics, game playing, and resource allocation.

The 2000s also saw embodied AI gain traction. Rodney Brooks at MIT argued that intelligence emerged from interaction with a physical environment, not from symbolic representations. His subsumption architecture for robots showed that surprisingly complex behaviour could emerge from simple reactive layers.

Reinforcement learning matters for agentic AI because it formalised the relationship between actions, rewards, and policies. The Markov decision process framework is still how I think about agent design at a high level. An agent observes a state, takes an action, receives a reward, and transitions to a new state. Whether the policy is learned through deep RL or expressed as an LLM prompt, the structure is the same.

The 2000s also saw early work on multi-agent reinforcement learning. Researchers studied how agents could learn to cooperate or compete in shared environments. The techniques developed here, including centralised training with decentralised execution, are relevant to modern multi-agent designs.

The deep learning revolution started with the 2012 ImageNet result from Krizhevsky and colleagues, where a convolutional network dramatically outperformed previous methods on image classification. The same techniques quickly spread to other modalities. By 2015, deep learning was the dominant approach in computer vision and was making rapid progress in speech and language.

For agents, the most consequential application was Deep Q Networks from DeepMind in 2015. DQN learned to play Atari games at human level from pixels alone, with no hand-crafted features. This was the first demonstration that deep learning could power a general agent. AlphaGo followed in 2016, beating the world champion at Go using a combination of deep learning and search.

These successes mattered because they showed that learned representations could scale. The hand-crafting that had limited symbolic AI for decades was no longer required. An agent could learn from data what to attend to, how to plan, and how to act.

The 2010s also saw the rise of large-scale language models, starting with word embeddings and progressing to recurrent networks and eventually transformers. The seeds of the LLM agent era were planted in the 2010s, though it took the transformer breakthrough to bring them to flower.

“Attention Is All You Need” by Vaswani and colleagues was published at NeurIPS 2017. The paper introduced the transformer architecture, which replaced recurrence with self-attention as the core mechanism for sequence modelling. The architecture turned out to scale beautifully, and within five years it had displaced every alternative for language modelling.

For agentic AI, the transformer mattered for two reasons. First, it made it possible to train models on truly large corpora of text, which is what unlocked the capability jumps we have seen since. Second, the architecture is well suited to tool use and structured output because attention can model long-range dependencies between inputs, intermediate reasoning, and outputs.

The transformer paper itself does not mention agents. The original application was machine translation. But the architecture is the substrate on which every modern LLM agent is built. Without the transformer, the rest of the history in this article would look very different.

GPT-3 was released by OpenAI in 2020. Its scale was unprecedented and its few-shot capabilities were a genuine surprise. Suddenly a single model could write essays, answer questions, and produce code with reasonable quality, all from a text prompt.

The two years that followed were the prompting era. Researchers and practitioners discovered that careful prompts could elicit capabilities that the model otherwise hid. Chain of Thoughts prompting, introduced in 2022, showed that asking the model to think step by step dramatically improved performance on reasoning tasks. The prompt itself became a unit of engineering.

This era set the stage for agentic AI by demonstrating that base language models could reason, plan, and write code at a useful level. The missing piece was tool use. A GPT-3 model could write an essay about how to look something up, but it could not actually look it up. Solving this gap was the next step.

The other contribution of this era was the chat format. ChatGPT, released in late 2022, made conversation the default interface to language models. The chat format is what made agentic systems intuitive to users. An agent that can answer follow-up questions and remember context across a conversation feels qualitatively different from a one-shot completion engine.

“ReAct: Synergizing Reasoning and Acting in Language Models” by Yao and colleagues was posted to arXiv in October 2022. The paper proposed interleaving chain of thought reasoning with explicit actions, where each action could call an external tool. The model would think, act, observe, and think again, in a single loop.

ReAct is the paper I credit with starting the modern agentic AI era. It is the first widely adopted recipe for turning a language model into an autonomous agent that can use tools to accomplish goals. The pattern is so foundational that almost every agent framework in 2026 implements something resembling ReAct as a baseline.

The contribution of ReAct was not the idea of combining reasoning and acting. That goes back to the earliest agent research. What was new was showing that a sufficiently capable language model could do both well in a single loop, with the reasoning trace itself serving as scratch space for the agent’s deliberation.

The paper also demonstrated empirically that ReAct outperformed alternatives on reasoning and decision-making benchmarks. That empirical grounding gave the technique the credibility it needed to spread quickly through the practitioner community.

AutoGPT was released in March 2023 by a developer named Toran Bruce Richards. It was a simple Python wrapper around GPT-4 that gave the model a goal, a set of tools, and a loop to keep working until the goal was achieved or the user stopped it. The project went viral on GitHub within days and became the most starred repository of the year.

AutoGPT was rough. It would often get stuck in loops, burn through API budgets, and produce mediocre output. But it was the first time most people had seen an LLM operate as an autonomous agent on real tasks. The public reaction was a mix of awe and concern, and it kicked off a year of intense activity in the space.

Within months, alternatives appeared. BabyAGI, AgentGPT, GPT Engineer, and a flood of derivatives each took a different angle. Frameworks like LangChain added agent abstractions to their libraries. Investors poured money into agent startups. The term agentic AI started appearing in product marketing and analyst reports.

The 2023 boom was equal parts genuine progress and hype. The agents of that year were not yet reliable enough for production deployment in most use cases. But the year established agents as the next frontier and gave developers everywhere a working baseline to improve on.

By 2024 it was clear that single agents had limits. The next wave of frameworks focused on multi-agent designs. AutoGen from Microsoft, CrewAI, LangGraph, and OpenAI’s Swarm all launched or matured in this period. Each took a different angle on how multiple agents should coordinate.

This was also the year that production deployment began in earnest. Coding agents like Devin and Cursor’s agent mode showed that LLM agents could handle real software tasks. Customer support agents began to replace tier one human support at several large companies. Research agents started showing up in legal, finance, and scientific workflows.

The standards layer started to crystallise too. Model Context Protocol, or MCP, was introduced by Anthropic as a standard for tool integration. The protocol decoupled tools from specific models or frameworks, which made it easier to compose agents across providers.

What I remember most from 2024 is the move from prototype to product. The earlier years had been about demonstrating that agents could work. 2024 was about making them reliable enough to ship. That shift forced a focus on evaluation, observability, and failure handling that the field had previously underinvested in.

2025 saw agentic AI move into the enterprise stack. Salesforce, ServiceNow, Microsoft, and Google each launched agent platforms targeted at enterprise IT. Custom agents started replacing rule-based automations in many back office processes. The total addressable market estimates for agentic AI ballooned into the trillions.

Standards continued to mature. A2A protocols for agent to agent communication appeared from multiple vendors. Reasoning model variants, where the model produces an internal chain of thought before responding, became the default for many production agents.

The labour market started to shift. AI agent engineer became a recognised role with its own salary bands. Several major consulting firms launched practices specifically focused on agentic AI implementation. Universities and bootcamps began offering dedicated programmes in agent design.

The other story of 2025 was safety. As agents moved into higher stakes use cases, the safety conversation moved from theoretical to operational. Regulators in the EU, US, and Asia started asking pointed questions about how autonomous agents would be governed. Several incidents involving misbehaving agents made headlines, which sharpened the urgency.

In 2026 agentic AI is in roughly the same place that mobile apps were in 2012. The technology works, the platforms are stable, and the question for most teams is not whether to adopt but how. The frameworks have matured, the patterns are documented, and there is enough production experience for engineers to learn from each other’s mistakes.

The current frontier is agents that learn from their own experience. Earlier agents used static prompts and pretrained models. New systems update their policies, tools, and routing decisions based on outcomes. This is an early step toward agents that genuinely improve over time without retraining.

Multi-agent designs are also becoming normal. The novelty has worn off, and we are in a phase of designing principled multi-agent systems with clear topologies, protocols, and governance. The pattern catalogue is richer than it was even eighteen months ago.

What is unsettled is the human-agent relationship. The default mode for most agents in 2026 is still tool-like. The user asks, the agent acts. The next stage, where agents act proactively on the user’s behalf, is technically feasible but socially and organisationally hard. That work will define the next few years.

Earlier waves of AI research carry lessons that the current generation should not ignore.

• Brittleness shows up in production: symbolic AI worked in demos and failed in the wild. Modern agents have the same risk. Evaluate broadly, not narrowly.
• Knowledge has to come from somewhere: hand-crafted expert systems did not scale. Hand-prompted agent behaviour will not scale either. Build mechanisms to capture knowledge from data and use.
• Frame problems are real: deciding what is relevant in a complex world is hard. Agents that try to consider everything fail. Designing the scope of attention is part of the engineering job.
• Evaluation is half the work: previous waves underinvested in evaluation and overinvested in capability. Modern agents need rigorous evals more than they need bigger models.
• Hype cycles repeat: every wave of AI has overshot in expectations before correcting. Plan for the long term, not the next quarter.

The history of AI is the history of repeatedly underestimating what was hard and overestimating what was close. Build with that pattern in mind.

The teams I see succeeding now are the ones that take these lessons seriously. They are deeply empirical, suspicious of demos, and patient about deployment.

If I extrapolate from the patterns of earlier waves, several things seem likely in the next few years.

First, the current excitement will produce overshoots that get corrected. Some prominent agent startups will fail spectacularly. Some prominent agent claims will prove unreliable. The field will adjust, and the survivors will be those who built on solid foundations.

Second, the next plateau will reveal new problems. Every wave of AI runs into a wall, and the wall always looks like a fundamental limit at first. The wall this time will probably involve some combination of evaluation, alignment, and the gap between narrow benchmarks and general utility.

Third, the integration with other technologies will be where the action moves. Pure agent research will give way to agent-plus-something. Agents plus simulation. Agents plus robotics. Agents plus structured data. The hybrid systems will outperform pure agents on real tasks.

Fourth, the social and organisational layer will matter more than the technical layer. Companies that figure out how to use agents well will outperform companies that have access to better models but worse processes. That is how every technology wave has played out, and there is no reason to expect this one to be different.