35 Years of Agents

Two papers came out in 1991 that disagreed on almost everything.

Brooks at MIT argued that agents don't need internal representations at all. Build them from stacked layers of reactive behavior. Sensors come in, actions go out. No thinking required. He called it the subsumption architecture, and it worked surprisingly well for simple robots.

That same year, Rao and Georgeff published the BDI model: Beliefs, Desires, Intentions. An agent should maintain an explicit model of what it knows, what it wants, and what it's committed to doing. The architecture was formal enough to prove properties about. You could verify that an agent would behave correctly before deploying it. BDI dominated multi-agent systems research for the next fifteen years.

These two camps set the terms for a debate that still hasn't been settled. The reactive school said: keep it simple, let behavior emerge from interaction with the environment. The deliberative school said: build internal models, plan explicitly, reason about goals. Every agent architecture since has been somewhere on this spectrum.

The standardization attempt

By the mid-90s, the multi-agent community had a practical problem. Agents built by different teams couldn't talk to each other. In 1996, FIPA, the Foundation for Intelligent Physical Agents, started publishing communication standards. The FIPA Agent Communication Language defined message types with formal semantics: inform, request, query, propose, accept, reject. Every message had a defined structure. Every interaction was machine-verifiable.

In 2000, JADE shipped. Built by Telecom Italia, it was a full platform for deploying multi-agent systems: agent lifecycle management, directory services so agents could find each other, and message transport following FIPA standards. For the first time, you could run thousands of coordinated agents on real infrastructure.

This wasn't academic anymore. JADE had an Agent Management System, basically a registry of who's alive and what they do; a Directory Facilitator, where agents advertise their capabilities and discover others; and a Message Transport Service, the communication backbone. Production-grade infrastructure for multi-agent coordination. In 2001.

The quiet years

Then deep learning showed up and ate the funding.

The 2010s belonged to convolutional networks, GANs, and eventually transformers. Multi-agent research didn't stop. QMIX came out of Oxford in 2018 with a clean solution to multi-agent credit assignment, and DeepMind's AlphaStar reached grandmaster level in StarCraft II in 2019 using multi-agent reinforcement learning. But these were reinforcement learning systems, not the kind of autonomous agents that BDI and FIPA had envisioned. The classical agent community faded from the main stage.

The game theory side kept producing useful results. Mechanism design gave us principled tools for task allocation: auction mechanisms, contract net protocols, voting systems. Shoham and Leyton-Brown's 2008 textbook systematized the whole field. But most of this work stayed in economics and theoretical CS departments. It rarely crossed over into practical agent deployment.

GPT-3 and the reset

In 2020, GPT-3 demonstrated something the agent community had never had access to: in-context learning. You could give a model instructions in plain English and it would follow them. No training loop. No reward function. No hand-coded rules. Just a prompt.

It took about two years for the implications to sink in. By early 2023, researchers started connecting LLMs to tools and running them in loops. Yao et al. published ReAct at ICLR 2023, establishing the thought-action-observation cycle that every modern agent uses. Schick et al. showed that LLMs could teach themselves when to call APIs with Toolformer. Shinn et al. built agents that reflected on their own failures and improved without weight updates through Reflexion.

In a single year, we went from "LLMs are chatbots" to "LLMs are autonomous agents that can search the web, execute code, and coordinate with each other."

The multi-agent return

The second half of 2023 and 2024 brought the multi-agent wave. Li et al. showed two LLMs cooperating through role-play with CAMEL. Hong et al. encoded entire software development teams into agent roles with MetaGPT. Wu et al. built a flexible conversation protocol where agents form group chats and the manager selects who speaks next with AutoGen. Qian et al. created a virtual software company of agents in ChatDev. Wang et al. stacked layers of LLMs refining each other's outputs in Mixture-of-Agents.

Alongside this, memory systems caught up. Park et al.'s Generative Agents introduced the memory stream: agents that remember, reflect, and plan based on past experiences. Packer et al.'s MemGPT applied OS-style memory paging to agent context. Sumers et al.'s CoALA framework provided a cognitive architecture distinguishing working, episodic, semantic, and procedural memory. By 2025, Xu et al.'s A-Mem had agents maintaining self-organizing Zettelkasten-style knowledge bases.

Security research followed, predictably a step behind. Greshake et al. defined indirect prompt injection as the canonical threat model. Zhan et al. and Debenedetti et al. built benchmarks. Zhang et al. formalized 10 attack types and 4 defense classes. All of this work is in English. All of it tests single agents or simple two-agent setups.

What we lost

I keep coming back to the comparison between where we were and where we are now.

FIPA gave us formal agent communication in 1996. Typed messages with defined semantics. Machine-verifiable interactions. AutoGen replaced all of that with natural language messages between agents. More flexible, sure. But you can't verify a conversation the way you can verify a FIPA protocol exchange. And every message is now a potential injection vector.

BDI gave us provable agent architectures in 1991. You could formally verify that an agent's intentions were consistent with its beliefs and desires. LLM agents replaced that with probabilistic text generation. More capable, no question. But the reasoning is a black box. When an agent makes a bad decision, you can't trace it to a specific belief or intention. You can only look at the tokens it generated.

JADE gave us standardized infrastructure in 2000. Agents built by different teams could discover each other and communicate through shared protocols. Today we have LangChain, AutoGen, MetaGPT, CrewAI, and AgentScope, and none of them interoperate. An AutoGen agent can't join a LangGraph workflow. A MetaGPT engineer agent can't be plugged into a CrewAI team.

We traded formalism for capability. That's not necessarily wrong. But the problems formalism solved - verification, security, interoperability - haven't gone away. They're just unsolved again.

Where this leaves us

The 70-paper survey I did across seven sub-domains of agentic AI from 2023 to 2026 confirmed something I suspected from the historical review: the individual branches are well-covered. Cognition has ReAct, Tree of Thoughts, Reflexion. Coordination has AutoGen, MetaGPT, CAMEL. Memory has MemGPT, HippoRAG, CoALA. Security has InjecAgent, AgentDojo, ASB. Evaluation has AgentBench, WebArena, SWE-bench.

What's missing is the intersection work. Security tested on multi-agent pipelines. Coordination tested in non-English languages. Memory systems that handle code-switching between Arabic script and Arabizi. Evaluation benchmarks for agents operating in Darija.

35 years of multi-agent research, and nobody has tested whether any of it works outside English. The classical MAS community never had this problem: FIPA protocols were language-agnostic. But LLM agents reason in a language. When that language is Darija, with four scripts, no standardized orthography, and constant code-switching with French, the entire coordination pipeline is affected.

That's not a footnote. That's a research program.