The History of AI Agents
From the simple environment, agent, action loop to reinforcement learning, ReAct, LangChain, and LangGraph. How standalone agents grew into today's frameworks.
An AI agent is a system that acts in an environment to reach a goal, over multiple steps, adjusting as it goes. The idea is older than the name, and its history explains why agent frameworks look the way they do today.
The simple loop
The canonical abstraction is environment, agent, action: the agent observes a state, chooses an action, the environment changes, and the loop repeats. This is the framing of reinforcement learning, and it is also, in plain words, exactly what a coding harness does when it reads files, runs a command, and reacts to the output. If you understand that loop, you understand the shape of every agent, including Claude Code and Codex.
Reinforcement learning agents
Before LLMs, the most impressive agents were trained by RL. DeepMind's DQN (2015) learned to play Atari from pixels, and AlphaGo (2016) beat the world champion at Go. These proved that the perceive, decide, act loop could master closed environments. What they could not do was act in the open-ended, language-shaped world of software development.
LLM agents: ReAct and function calling
The bridge was language. The ReAct pattern (2022) had a model interleave reasoning steps and tool actions, effectively letting the model "think" between actions. OpenAI added function calling to its API in 2023, which made tool use a native, structured capability. Suddenly an LLM could be told it has a search tool or a shell, and it would choose to call them as part of completing a task. That is the moment standalone LLM agents became practical.
LangChain and LangGraph
LangChain (late 2022) popularized chaining LLM calls and tools into pipelines and gave the ecosystem a common vocabulary. Its successor, LangGraph (2023), modeled agents as explicit graphs: nodes are steps, edges are decisions, and state flows between them. The graph framing made loops, branching, and human-in-the-loop checkpoints first-class, and it became the standard way to build robust multi-step agents. Around the same time, AutoGPT-style experiments showed both the appeal (autonomous task execution) and the danger (uncontrolled loops) of giving agents long autonomy.
Agents today
Modern agent platforms, from OpenAI's Agents SDK to Claude's subagents to LangGraph, standardize the hard parts: tool definitions, orchestration, memory and state, guardrails, and observability. The progression from a naive loop to a managed graph is the same progression the industry is living through, and it is directly relevant to AI coding interviews, where "agentic" system design is becoming its own interview format.
The one-sentence history
Games proved agents could act, ReAct and function calling made them speak, LangChain and LangGraph made them orchestrate, and today's SDKs make them safe enough to ship.
Sources and further reading
Premium
Unlock the rest of this guide
Premium unlocks every pattern deep-dive, every problem breakdown and solution, the practice sandbox, and verdict feedback on your practice runs.
- The agent loop is just perceive, decide, act, and repeat, with a memory of what happened.
- RL agents proved the loop at scale in games; LLM agents made it language-driven.
- ReAct, function calling, LangChain, and LangGraph turned one-shot LLM calls into multi-step agents.
- Today's agent SDKs standardize tools, orchestration, and guardrails.
- The full article, complete and uninterrupted
- All pattern deep-dives and problem breakdowns
- Practice sandbox and verdict feedback