53 Years in the Making
A companion to GUTENBERGINLINETOKEN0END (Part 11 in the series).
Current discussion often uses “agent” without reference to the term’s long history in computer science. That history includes several competing formal models, programming languages, and production systems. It offers definitions and design questions rather than one settled architecture.
This reading list traces that lineage chronologically, from the foundational theoretical work in the 1970s through the systems that put agents into production, to the convergence with large language models. Each entry includes why it matters for understanding where we are now.
Read Wooldridge & Jennings (1995) first. Everything else follows from it.
I. Foundations (1973–1995)
The theoretical and architectural groundwork. These papers defined what an agent is, how agents reason, and how they coordinate.
1. Hewitt, C., Bishop, P., Steiger, R. “A Universal Modular ACTOR Formalism for Artificial Intelligence.” (1973)
IJCAI 1973. (ACM Digital Library)
The Actor model. An actor receives a message, performs computation, sends messages, and creates new actors without sharing mutable state. The paper strongly influenced later work on actors and message-passing concurrency, including systems such as Erlang.
Read for: A rigorous account of message passing and isolated state as one durable approach to concurrent systems.
2. Bratman, M. “Intention, Plans, and Practical Reason.” (1987)
Harvard University Press / CSLI Publications.
The philosophical foundation for the BDI (Belief-Desire-Intention) model. Bratman was a philosopher reasoning about how humans make and execute plans. He treated an intention as a commitment that constrains future deliberation, rather than as a strong desire. An agent that forms an intention follows through unless conditions change.
Read for: The distinction between a desire and a plan that constrains later choices. BDI systems formalized part of Bratman’s account; an LLM plan can be compared with it functionally without assuming that the model has human mental states.
3. Brooks, R. “Elephants Don’t Play Chess.” (1990)
Robotics and Autonomous Systems 6(1–2), 3–15.
Brooks challenged symbolic AI by arguing that useful behavior can emerge from simple reactive rules interacting with an environment, without an explicit internal world model. His Subsumption Architecture combined simple behaviors into more complex action. Modern language models do not settle his argument, but they make the relation between learned representations and effective action newly relevant.
Read for: A strong alternative to BDI and a precursor to today’s dispute over whether agent behavior requires explicit reasoning.
4. Rao, A.S., Georgeff, M.P. “Modeling Rational Agents within a BDI-Architecture.” (1991)
Proceedings of the 2nd International Conference on Principles of Knowledge Representation and Reasoning (KR’91).
Rao and Georgeff formalized BDI as a computational architecture: agents maintain beliefs about the world, desired outcomes, and intentions to which they are committed. The deliberation cycle perceives an event, updates beliefs, generates options, selects intentions, and acts. Many later agent systems adopted or responded to this model.
Read for: The architecture diagram, then compare its state, deliberation, and action steps with a modern coding agent’s control loop.
5. Shoham, Y. “Agent-Oriented Programming.” (1993)
Artificial Intelligence 60(1), 51–92.
The paper that coined “agent-oriented programming.” Shoham proposed AGENT-0, the first agent-oriented programming language, where agents are programmed in terms of mental categories: beliefs, capabilities, commitments, and commitment rules. Garcia-Montoro et al. classify this as the origin of “commitment agents.”
Read for: The argument for programming agents in terms of beliefs and commitments rather than only procedural control flow. Natural-language goals for LLM agents create an interesting comparison, though the implementation differs substantially.
6. Finin, T. et al. “KQML as an Agent Communication Language.” (1994)
Proceedings of the Third International Conference on Information and Knowledge Management (CIKM’94).
KQML defined structured message types for requesting, telling, asking, and subscribing. FIPA ACL followed in 1997 with refined semantics. These standards address a problem that also appears in tool protocols such as MCP: typed communication across an agent boundary. The similarity does not by itself establish direct descent.
Read for: Earlier attempts to standardize agent communication and the design choices that recur in current tool protocols.
7. Russell, S., Norvig, P. “Artificial Intelligence: A Modern Approach.” (1995)
Prentice Hall. (4th edition, 2020)
The textbook that unified AI around the concept of “rational agents.” Russell and Norvig presented search, logic, planning, learning, and perception as capabilities of agents operating in environments. The book made “agent” a frame for the whole field instead of one subfield. Computer science students have learned that definition for three decades.
Read for: A canonical definition against which looser current uses of “agent” can be compared.
8. Wooldridge, M., Jennings, N.R. “Intelligent Agents: Theory and Practice.” (1995)
Knowledge Engineering Review 10(2), 115–152.
The anchor paper. The most cited survey in the agent literature. Wooldridge and Jennings defined the properties that make an agent intelligent: autonomy, social ability, reactivity, and proactivity. They surveyed the theoretical foundations (BDI, reactive architectures, hybrid architectures) and the practical implementations available at the time.
Those properties remain useful questions for current AI agents: which actions are autonomous, how the system communicates, what events it reacts to, and whether it initiates plans. Different products answer them differently.
Read for: A definition that forces the writer to specify which agent properties a system actually has.
II. Languages and Architectures (1995–2004)
The period when agent theory became agent engineering. Programming languages, platforms, and standards for building agent systems.
9. Nwana, H.S. “Software Agents: An Overview.” (1996)
Knowledge Engineering Review 11(2), 205–244.
A practical taxonomy of collaborative, interface, mobile, information, reactive, and hybrid agents. Nwana classified them by their behavior in practice as well as their theoretical properties.
Read for: The breadth of what “agent” already meant in 1996. Today’s coding, research, and tool-using agents form a subset of the systems this paper surveys.
10. Jennings, N.R., Sycara, K., Wooldridge, M. “A Roadmap of Agent Research and Development.” (1998)
Journal of Autonomous Agents and Multi-Agent Systems 1(1), 7–38.
The paper surveyed open questions in multi-agent coordination, negotiation, trust, and organizational structure. Some now recur in LLM-agent systems, while others developed along different paths.
Read for: A record of which coordination problems were already understood in 1998 and which assumptions differ from current LLM systems.
11. Armstrong, J. “Making Reliable Distributed Systems in the Presence of Software Errors.” (2003)
PhD Thesis, Royal Institute of Technology, Stockholm.
Joe Armstrong’s doctoral thesis. The theoretical and practical foundation of Erlang/OTP. Armstrong argues that a system must recover from errors it cannot prevent. The thesis formalizes supervision trees, process isolation, hot code reloading, and “let it crash.”
Read for: The architecture of fault-tolerant process systems. Isolation, supervision, and recovery deserve explicit consideration in AI-agent design even though model failures differ from Erlang process failures.
12. Varela, C., Abalde, C., Castro, L., Gulías, J. “On Modelling Agent Systems with Erlang.” (2004)
Erlang’04: Proceedings of the 2004 ACM SIGPLAN Workshop on Erlang.
The paper mapped BDI components onto Erlang processes: event receiver, state server, executor, and main process. Agents cooperated by message passing, and supervision trees supported recovery. The implementation shows that BDI can be expressed through Erlang’s process model; it does not make the two architectures identical.
Read for: A concrete meeting of agent theory and systems engineering. Compare the diagram on page 66 with a coding agent while noting where the analogy stops.
III. Production Systems (2004–2013)
Agents move from research to production. The lessons learned when agent architectures meet real-world reliability requirements.
13. Armstrong, J. “Programming Erlang: Software for a Concurrent World.” (2007)
Pragmatic Bookshelf.
The practitioner’s guide to building agent-based systems in Erlang. Where the thesis was theoretical, this book is operational. Process spawning, message passing, supervision trees, distributed Erlang, OTP patterns — all explained through working code.
Read for: gen_server, gen_fsm, and supervisor patterns, and for a vocabulary with which to evaluate failure handling in AI-agent frameworks.
14. Cantrill, B., Shapiro, M., Leventhal, A. “Dynamic Instrumentation of Production Systems.” (2004)
USENIX Annual Technical Conference 2004.
DTrace gave operators dynamic visibility into kernel and user-space behavior. Reliable agent systems likewise need records of tool calls, messages, state changes, and results. DTrace is useful here as a model of low-overhead, on-demand instrumentation, not as a claim that model internals are directly observable.
Read for: The observability principle. A system cannot inspect a model’s private computation directly, but it can record tool calls, messages, state transitions, and external effects.
15. Joyent. “Manta: Object Storage with Integrated Compute.” (2013)
Architecture documentation and API reference. (Job Patterns)
The distributed Unix pipeline built on agent architecture. Manta ran Unix tools inside isolated compute zones (SmartOS zones + ZFS + DTrace) against a distributed object store. Every job pattern — word count, ETL, video transcode — was a composition of isolated agents communicating through text.
Read for: A production example of Unix-style composition across distributed, isolated compute. MCP and coding agents reuse some of the same boundary and composition ideas.
IV. The Neural Turn (2014–2022)
Machine learning introduced agents whose policies are learned rather than fully specified by programmed rules. Some earlier architecture problems remained; others changed.
16. Sutton, R., Barto, A. “Reinforcement Learning: An Introduction.” (1998)
MIT Press. (2nd edition, 2018)
The foundational text for reinforcement learning. Sutton and Barto present the agent-environment interface: an agent observes state, takes actions, receives rewards, and updates its policy. Markov decision processes underlie DQN and AlphaGo and inform reinforcement-learning methods used in language-model training.
Read for: The mathematical formalization of what it means to be an agent that learns. Every LLM fine-tuned with RLHF is using the framework this book established.
17. Mnih, V. et al. “Playing Atari with Deep Reinforcement Learning.” (2013)
arXiv:1312.5602.
DeepMind’s DQN paper describes an agent that learns to act from raw pixel input. DQN is not BDI: it learns a Q-function rather than symbolic beliefs or intentions. It nevertheless perceives an environment, maintains learned representations, and takes actions to increase expected reward.
Read for: The moment when “agent” in AI stopped meaning “rule-based system” and started meaning “learned behavior.” The formal architecture changed. The core abstraction — perceive, reason, act — didn’t.
18. Vaswani, A. et al. “Attention Is All You Need.” (2017)
NeurIPS 2017.
The Transformer is not an agent architecture, but it underlies the language models used by current LLM agents. Attention lets a model condition each token on relevant parts of its context.
Read for: The mechanism by which a language model weights information across its input, one component of maintaining working context in an agent loop.
19. Silver, D. et al. “Reward Is Enough.” (2021)
Artificial Intelligence 299, 103535.
DeepMind argues that perception, language, and social intelligence can emerge from reward maximization in sufficiently complex environments. The claim is controversial and provides one theory, rather than a settled conclusion, about general intelligence.
Read for: The theoretical claim that agent-based architectures are sufficient for general intelligence. Whether or not you agree, it’s the intellectual backdrop for why everyone is building agents now.
V. LLM Agents (2022–2025)
Large language models become agents. The old problems return.
20. Yao, S. et al. “ReAct: Synergizing Reasoning and Acting in Language Models.” (2022)
arXiv:2210.03629.
The paper formalized a pattern in which an LLM alternates reasoning traces with actions. ReAct can be compared with a BDI deliberation cycle: context supplies state, the task supplies a goal, and generated actions update the next observation. It does not implement formal BDI semantics.
Read for: The direct mapping between the 1991 BDI cycle and modern LLM agent behavior. Rao & Georgeff would recognize this immediately.
21. Schick, T. et al. “Toolformer: Language Models Can Teach Themselves to Use Tools.” (2023)
arXiv:2302.04761.
Toolformer shows language models learning when and how to call APIs, calculators, and search engines. Tool calls create a structured boundary between the model and an external process, comparable in one respect to message passing.
Read for: The transition from LLMs as text generators to LLMs as tool-using agents. MCP is the standardized version of what this paper demonstrated.
22. Park, J.S. et al. “Generative Agents: Interactive Simulacra of Human Behavior.” (2023)
arXiv:2304.03442.
Stanford’s paper placed 25 LLM agents in a simulated town with memory, planning, and reflection. Those components invite a BDI comparison, although the paper’s implementation is not a formal BDI system.
Read for: How memory, planning, and reflection are implemented with an LLM, and where that implementation resembles or departs from BDI.
23. Anthropic. “Model Context Protocol (MCP).” (2024)
Open specification. (GitHub · Announcement)
MCP standardizes communication between an AI application and external tools through structured requests and responses with typed parameters and results. Architecturally, it is a protocol across an agent-to-tool boundary.
Read for: The differences as well as the analogy. MCP uses JSON-RPC and client-server tool calls; Erlang supports asynchronous peer-to-peer process messages. Both make a communication boundary explicit.
24. García-Montoro, C., Vivancos, E., García-Fornes, A., Botti, V.J. “A Software Architecture-Based Taxonomy of Agent-Oriented Programming Languages.” (2008)
Technical University of Valencia.
A taxonomy of agent programming languages classified not by philosophical properties but by software architecture: commitment agents, event-driven agents, goal-directed agents, software-integration agents, hierarchical agents, task-and-communication agents. Six architectures, each with different trade-offs.
Read for: The architectural diversity that existed before LLMs collapsed everything into “prompt → tool call → response.” The taxonomy reveals design choices that the current LLM agent frameworks don’t even know they’re making.
VI. The Convergence (2025)
25. Anthropic. “Claude Code.” (2025)
CLI tool and documentation.
A frontier LLM operating as an agent in a terminal. It receives prompts, maintains conversation and file context, forms plans, calls tools, and adjusts after failures. Claude Code is written in Bun. Its resemblance to BDI and Erlang is a structural comparison; no direct influence is asserted here.
Its control loop can be analyzed with BDI terms, its tool protocol passes messages, and its terminal interface composes with Unix tools.
Read for: A current system against which to test the distinctions in the earlier papers: autonomy, state, intention, communication, observation, and recovery.
How to Read This List
If you read three papers: Wooldridge & Jennings (1995), Armstrong’s thesis (2003), and the ReAct paper (2022). That gives you the definition, the systems engineering, and the modern implementation.
If you read five: Add Rao & Georgeff (1991) for the formal BDI model and Varela et al. (2004) for the Erlang mapping.
If you’re building agent systems: Read Armstrong’s thesis and his Erlang book. Then read everything your framework doesn’t implement and ask why.
The common structure: An agent is an autonomous process that maintains state, forms intentions, and communicates through messages. Hewitt described part of this structure in 1973; Rao and Georgeff formalized BDI in 1991; Wooldridge and Jennings defined agents in 1995; Erlang and SmartOS supplied production implementations; language models now perform related functions in terminals. The implementations changed while the requirements for state, action, and communication persisted.
The fifty-three years between Hewitt’s Actor model and a coding agent contain both continuity and change. The older work supplies comparisons, counterexamples, and engineering methods; it should inform current design without being forced into a single lineage.