Multi-Agent Orchestration: A History

From FIPA agent standards to LangGraph and CrewAI. Click any milestone to expand.

Academic / Standards
Early Frameworks
LLM Era
Modern Frameworks
1997 FIPA: The First Multi-Agent Standard Academic
The Foundation for Intelligent Physical Agents published specifications for how software agents should communicate, discover each other, and coordinate tasks. FIPA-ACL (Agent Communication Language) defined message types: REQUEST, INFORM, QUERY-IF, PROPOSE. Agents were expected to negotiate, not just execute sequentially.
→ Established vocabulary that survives in modern frameworks: agent roles, message passing, task delegation
2000 JADE: Java Agent Development Framework Academic
JADE implemented the FIPA specifications in Java. It shipped with an agent lifecycle management system, a yellow-pages service (DF) for agent discovery, and message transport between agents on different machines. Used heavily in academic robotics and distributed simulation research.
→ Showed that multi-agent systems were buildable — but required substantial infrastructure just to get two agents talking
2008 AutoGen predecessors: task delegation in enterprise workflow engines Frameworks
BPM (Business Process Management) systems like Activiti and jBPM modelled workflows as directed graphs of tasks, with human and automated agents at each node. The insight: orchestration is a graph problem. The gap: these systems required dedicated workflow servers, XML process definitions, and database-backed state — far too heavy for ad-hoc agent pipelines.
→ Graph-based orchestration predates LangGraph by 15 years. LangGraph is this idea applied to LLM nodes.
2023 Q1 AutoGPT: First Viral LLM Agent LLM Era
AutoGPT gave GPT-4 a loop: generate a plan, execute steps, observe results, refine. It required no orchestration framework — just a while loop and tool calls. 100,000 GitHub stars in a week. Also: it frequently spiralled into useless loops, forgot its goal, and burned through API credits without finishing tasks. The viral moment exposed both the promise and the failure modes of autonomous LLM agents.
→ Proved the concept. Proved the problem. Every subsequent framework was built to fix what AutoGPT broke.
2023 Q3 LangChain Agents + AgentExecutor LLM Era
LangChain shipped AgentExecutor as its answer to the AutoGPT loop: structured, with return_intermediate_steps, verbose logging, max_iterations, and handle_parsing_errors. A single agent with tools — not yet multi-agent. But the observability primitives it added (step-by-step trace access) established the baseline for what production-ready agent execution looks like.
→ Set the standard for agent observability that SynapseKit would later underinvest in
2023 Q4 CrewAI: task-centric multi-agent orchestration LLM Era
CrewAI introduced the Crew/Agent/Task abstraction: define agents with roles, define tasks with expected outputs and context dependencies, let the framework manage the execution sequence. This is the mental model SynapseKit's Crew borrowed directly. The key insight: most multi-agent pipelines are linear task chains, not complex graphs. Abstract the graph away and let engineers write agent definitions, not routing code.
→ SynapseKit's Crew API is a near-direct fork of CrewAI's design philosophy
2024 Q1 LangGraph: graph-centric multi-agent orchestration Modern
LangChain rebuilt multi-agent from scratch with LangGraph. Instead of hiding the orchestration, LangGraph exposes it: you define a StateGraph with typed state, add nodes (functions), add edges (transitions), add conditional edges (routing logic). The LLM is just a function — it has no special orchestration privileges. Result: the most flexible multi-agent framework available, and the most structural code to write for simple cases.
→ Answers the AutoGPT failure: every transition is explicit code, not LLM improvisation
2024 Q2 LlamaIndex AgentWorkflow: emergent handoff Modern
LlamaIndex added AgentWorkflow as its multi-agent primitive. Unlike LangGraph's explicit edges and SynapseKit's declared task dependencies, AgentWorkflow lets agents hand off via tool calls — the LLM running the researcher agent decides when to call handoff_to_writer(). Elegant for simple cases. Unpredictable when the LLM decides not to hand off, or hands off at the wrong point. Supports sequential handoff chains; no parallel execution.
→ Highest conceptual elegance, lowest determinism — the tradeoff is fundamental to the design
2024 Q4 SynapseKit Crew + SupervisorAgent Modern
SynapseKit shipped its multi-agent layer: Crew (sequential/parallel task chains), SupervisorAgent (routes tasks to specialist agents), HandoffChain (explicit agent-to-agent passing), and StateGraph (for full DAG orchestration). Full pattern coverage across all 6 orchestration types, with the lowest setup LoC for sequential pipelines. The gap: intermediate step visibility is not exposed at the same level as LangGraph's AgentExecutor.
→ Most complete pattern library. Setup speed wins short-term. Observability gap surfaces in production.
www.engineersofai.com · AI Letters #26 · LLM Showdown Notebook #18