The Agent Handbook

Appearance

A Brief History of Agents

At a glance From ELIZA in 1966 to the 2025 coding-agent arms race — sixty years of intellectual history and five years of technical explosion for AI agents, explaining why ReAct, function calling, MCP, A2A, and other milestones appeared when they did, and distilling three reusable historical patterns.

A Brief History of Agents ​

Before the word "Agent" was worn out in AI, it already had sixty years of history behind it. Understanding that history isn't nostalgia — the pitfalls AutoGPT hit in 2023 had all been hit by BDI researchers in 1995; the problem MCP solves in 2025 is structurally the same one that stumped expert systems in the 1980s. The point of reading history: when the next hot thing appears, you can judge whether it's a genuine paradigm shift or old ideas with a new engine.

This page unfolds in five periods: the pre-LLM era of intellectual preparation (1966–2019), the methodological foundations of the eve of the GPT era (2020–2022), the Cambrian explosion of 2023, the engineering consolidation of 2024, and the "year of the agent" of 2025–2026. If you'd like the conceptual framework first, read What Is an AI Agent and come back to the history.

1. The Pre-LLM Era (1966–2019): The Ideas Were All There; the Engine Was Missing ​

1.1 ELIZA and Shakey: Two Prototypes of the Agent ​

In 1966, Joseph Weizenbaum at MIT published ELIZA — a conversational program that imitated a psychotherapist using pattern matching and substitution rules. ELIZA had no understanding whatsoever: it rewrote the user's statements as questions and tossed them back, yet many users became convinced the machine understood them. Weizenbaum himself was deeply troubled by this and went on to become one of AI's most famous critics.

ELIZA's legacy is double-edged: it demonstrated the powerful persuasive power of a conversational interface, and it exposed for the first time the trap later called the "ELIZA effect" — humans instinctively take fluent language output as evidence of intelligence. The public's inflated expectations of AutoGPT in 2023 were, at bottom, the ELIZA effect reprised for the LLM era.

Around the same time (1966–1972), SRI International's Shakey robot took a different route: it sensed its environment with a camera, used the STRIPS planner to decompose goals like "push the box into the other room" into action sequences, and then drove its wheels to execute them. That sense–plan–act triad is the direct ancestor of today's Agent Loop. The difference: Shakey's planner could only handle a hand-modeled symbolic world, whereas today's agents use an LLM to reason directly about the open world.

   Shakey (1969)                     Modern LLM Agent (2025)
 ┌───────────────┐                ┌───────────────┐
 │ Camera/sensors │                │ Context window │
 └──────┬────────┘                └──────┬────────┘
        ▼                                ▼
 │ World model (symbolic)│        │ LLM (implicit world model)│
 └──────┬────────┘                └──────┬────────┘
        ▼                                ▼
 │ STRIPS planner  │     ───►       │ Reasoning+planning (CoT/ReAct)│
 └──────┬────────┘                └──────┬────────┘
        ▼                                ▼
 │ Wheels/actuators │               │ Tool calls (function call)│
 └───────────────┘                └───────────────┘

1.2 Expert Systems: the First "AI in Production" Bubble ​

Through the 1970s–80s, AI's flagship was the expert system: encode a domain expert's knowledge as if-then rules and let an inference engine execute them. Stanford's MYCIN (1970s) could diagnose bloodstream infections and recommend antibiotics, reportedly reaching about 65% accuracy — better than some non-specialist physicians; DEC's XCON configured VAX computers from 1980 onward, reportedly saving the company tens of millions of dollars a year. Expert systems kicked off the first commercialization wave in the early 1980s, and Japan's national "Fifth Generation Computer" project bet the country on it.

Then it all collapsed in the late 1980s. The reasons remain extremely instructive for today's agent builders:

  • The knowledge acquisition bottleneck: squeezing tacit expert knowledge into rules cost more than the value it produced.
  • Brittleness: once the rule base was pushed past its design boundary, the system didn't get "a bit dumber" — it produced absurd answers outright. No graceful degradation.
  • Maintenance hell: the interactions among thousands of rules were beyond anyone's comprehension; fixing one rule could break ten.

The Lisp machine market crash around 1987, combined with the burst of the expert-system bubble, brought on the second AI winter. The lesson got distilled into one sentence: hand-injected knowledge is a dead end; intelligence must be learned at scale from data and experience — which is precisely why machine learning and later LLMs won.

1.3 BDI and Multi-Agent Systems: Agent Theory Comes of Age ​

In the depths of the winter, academia laid the theoretical groundwork for agents. In his 1987 book Intention, Plans, and Practical Reason, philosopher Michael Bratman proposed that a rational agent's behavior can be described with three mental states: Belief, Desire, and Intention. Anand Rao and Michael Georgeff formalized this into the BDI model in the early 1990s and published "BDI Agents: From Theory to Practice" in 1995; that same year, Michael Wooldridge and Nicholas Jennings published the survey "Intelligent Agents: Theory and Practice," systematically defining an agent's autonomy, social ability, reactivity, and pro-activeness.

This generation of research (historically "distributed artificial intelligence" / multi-agent systems, MAS) contributed a conceptual vocabulary still in use today: goal-driven behavior, commitment, agent communication languages (KQML/FIPA ACL), the Contract Net protocol. When Google launched the A2A protocol in 2025 to solve agent-to-agent interoperability, anyone who knows this history will notice: the problem hasn't changed; what was missing back then was a smart enough executor to make these protocols worthwhile.

An irony of history

MAS research in the 1990s died engineering-wise from "every agent was too dumb" — agents built from rules and symbolic reasoning couldn't even handle their own domain, let alone collaborate. Once the LLM patched the "single-agent intelligence" weakness, the 1995 theoretical framework came back to life almost unchanged. Concepts live far longer than technologies.

1.4 Reinforcement Learning Agents: the Other Bloodline ​

Running parallel to symbolic AI was the reinforcement learning (RL) route: learning from trial and error. This line produced a string of milestones in agent history:

  • In 1992, Gerald Tesauro's TD-Gammon played backgammon with a neural network plus temporal-difference learning and reached top-human level — the first proof that "self-taught can beat hand-crafted rules."
  • In 1997, IBM's Deep Blue beat world chess champion Garry Kasparov with brute-force search — but that was an engineering victory, not "learning."
  • In 2013–2015, DeepMind's DQN learned to play dozens of Atari games from raw screen pixels and scores alone, made the cover of Nature, and opened the deep reinforcement learning era.
  • In March 2016, AlphaGo beat Lee Sedol 4–1; in 2017, AlphaGo Zero discarded human game records entirely, trained purely by self-play, and crushed the original AlphaGo 100–0. Monte Carlo Tree Search + deep networks + self-play became the standard recipe for "training superhuman agents in closed, rule-based environments."
  • In 2019, AlphaStar (StarCraft II) and OpenAI Five (Dota 2) beat human professionals, pushing RL agents into partially observable, long-horizon, multi-agent games.

The RL bloodline's contribution to LLM agents is often underestimated: it left us the strict definition "agent = an entity that learns a policy in an environment via reward signals," it contributed algorithms like PPO (later the engine of RLHF), and it left a sobering reminder — superhuman game agents don't transfer to the open world, because games have explicit reward functions and the real world doesn't. Building a reward function for the real world had to wait for RLHF.

1.5 Interlude: What the Pre-LLM Era Was Missing ​

By 2019, the "body blueprint" of the agent was actually complete: the sense–plan–act loop (Shakey), goal and intention management (BDI), learning from experience (RL), agent collaboration protocols (MAS). What was genuinely missing were three things:

  1. General language understanding — the ability to understand tasks described in arbitrary natural language, not predefined symbols;
  2. General world knowledge — common-sense and domain knowledge that didn't have to be hand-entered;
  3. Graceful degradation — on out-of-distribution inputs, produce "roughly reasonable" output rather than "absurd" output.

Those three are exactly what the LLM delivered in one stroke.

2. The Eve of the GPT Era (2020–2022): Laying the Methodological Foundations ​

2.1 GPT-3: Prompt Engineering Arrives ​

In May 2020, OpenAI published the GPT-3 paper (arXiv:2005.14165). A 175-billion-parameter model was not itself the news — the real discovery was in-context learning: no fine-tuning required, just a few examples in the prompt (few-shot), and the model could temporarily "learn" a new task. This meant the way you configured AI capability changed from "training" to "writing a paragraph."

Prompt engineering was born. In hindsight, that was a pivotal leap in agent history: an agent's "program" could be written in natural language for the first time, and the system prompt became an executable statement of intent. Nearly every technique discussed today in Prompt Engineering traces back to here.

2.2 InstructGPT: Alignment Made Models "Usable" ​

GPT-3's problem was that it could only "continue text," not "follow instructions." InstructGPT, announced by OpenAI in January 2022 with the paper in March (arXiv:2203.02155), fixed this with RLHF (reinforcement learning from human feedback): human labelers ranked model outputs, a reward model was trained on the rankings, and PPO fine-tuned the policy. The conclusion was counterintuitive — the 1.3B-parameter InstructGPT was judged more helpful and obedient than the 175B GPT-3.

RLHF's significance for agents: for the first time, the open world got an optimizable "reward signal." The RL-era deadlock of "the real world has no reward function" was bypassed by "learn a reward model from human preferences."

2.3 Chain-of-Thought and ReAct: the Twin Cornerstones of Reasoning and Action ​

In January 2022, Jason Wei and colleagues at Google Brain published Chain-of-Thought Prompting (arXiv:2201.11903): merely demonstrating "step-by-step reasoning" in the prompt caused large jumps in math and logic performance. CoT revealed a fact exploited ever since: an LLM's reasoning ability isn't absent — it needs the generation process to "draw it out."

In October 2022, Shunyu Yao and colleagues at Princeton and Google published ReAct (arXiv:2210.03629), extending CoT from "pure thinking" to an interleaved "think + act" loop: the model alternates between Thought (reasoning), Action (calling tools/retrieval), and Observation (the results) until it produces an answer. The triad looks unremarkable, but it unified reasoning and tool use and became the runtime skeleton of nearly every LLM agent since — the loops you see in LangGraph, the Claude Agent SDK, and the OpenAI Agents SDK today are all ReAct's descendants. For a close reading of the paper, see Core Papers.

Also in October 2022, Harrison Chase open-sourced LangChain — at first just a small Python library packaging "prompt templates + external calls + chain composition." Its message: once the methodology is settled, engineering frameworks follow immediately, even while the models are still far from strong enough.

2.4 ChatGPT: the Sum of All Fuses ​

On November 30, 2022, OpenAI applied the InstructGPT recipe to GPT-3.5, wrapped it in a chat interface, and released ChatGPT. One million users in five days, one hundred million in two months. This was not an agent event, but it completed every precondition for the agent explosion: the public accepted conversational interfaces, developers got a cheap and capable instruction-following model API, and capital started believing "AI can do things." On March 14, 2023, GPT-4 shipped — the first model "smart enough to serve as an agent engine."

All the fuses were laid. All that was missing was the match.

3. The Cambrian Explosion (2023): the First Carnival of Autonomous Agents ​

3.1 AutoGPT and BabyAGI: Phenomenal Open Source ​

In late March 2023, Toran Bruce Richards open-sourced AutoGPT on GitHub: give GPT-4 a goal, and it decomposes tasks, searches the web, reads and writes files, and loops until the goal is done. Within three weeks of release (mid-April) it passed 70,000 stars, becoming one of the fastest-growing projects in GitHub history at the time, eventually crossing 150,000. In early April, Yohei Nakajima released the far more minimal BabyAGI — roughly 140 lines of Python, a task queue plus an execution loop, demonstrating the minimal closed loop of "task creation → prioritization → execution → re-planning."

Neither project was technically sophisticated, but together they ran a massive social experiment: they showed hundreds of thousands of people what "AI doing the work itself" looks like. The honest postmortems that followed matter just as much — AutoGPT fell into infinite loops on long tasks, accumulated hallucinations, and burned money uncontrollably; the vision of a "fully autonomous universal agent" proved far beyond what the models of the day could deliver. That judgment read as cold water at the time and proved accurate in hindsight: AutoGPT's architecture wasn't wrong — the engine just wasn't built yet. See the AutoGPT case.

3.2 Generative Agents: the Stanford Smallville ​

In April 2023, Joon Sung Park and colleagues at Stanford and Google published "Generative Agents: Interactive Simulacra of Human Behavior" (arXiv:2304.03442): 25 LLM-driven virtual inhabitants lived in a pixel-art town, each with schedules, memories, and social relationships. The researchers provided a single seed — "Isabella wants to organize a Valentine's Day party" — and two days later the party had spontaneously organized itself: invitations, word of mouth, attendance, all emergent agent behavior.

The paper's lasting engineering contribution outshines the "small town" gimmick: the memory architecture of memory stream + reflection + retrieval scoring remains the classic reference for agent memory system design. It also lit the fuse on the "multi-agent social simulation" research line.

3.3 Function Calling: from Free Text to Structured Calls ​

On June 13, 2023, OpenAI introduced function calling in an API update: developers hand the model function signatures (JSON Schema); when needed, the model emits a structured function name and arguments; external code executes and feeds results back. It looks like a minor API improvement, but it was a watershed for agent engineering:

  • Before: tool calling relied on prompt conventions about output format (ReAct style) — fragile parsing, high error rates;
  • After: "model decision + structured output" became a first-class citizen, and tool-call reliability reached production-grade for the first time.

In the same period, LangChain, LlamaIndex, and other frameworks grew explosively, and "LLM application development" became a job title of its own. In October, the Princeton team released SWE-bench — a benchmark testing models' bug-fixing ability on real GitHub issues — providing the scoreboard for the following year's coding-agent arms race.

Why did 2023's autonomous agents mostly fail while 2025's coding agents succeeded?

The difference isn't architecture; it's three things: models got two generations stronger (a qualitative jump in reasoning), the task was chosen well (code has compilers and tests as verifiers — naturally verifiable), and humans stayed in the loop (approving critical operations). AutoGPT wanted to be the "universal employee"; Claude Code only wants to be a "dependable pair programmer." Narrower ambition opened the market.

4. Engineering Consolidation (2024): from Demo to Product ​

4.1 RAG Matures and "Compound AI Systems" ​

2024's theme was industrializing 2023's wild ideas. RAG evolved from the naive "embeddings + vector store" recipe into a full craft — query rewriting, hybrid retrieval, reranking, evaluation loops — and became the default architecture for enterprises putting LLMs into production. Berkeley's "Compound AI Systems" position spread through industry: competitiveness comes from the system (model + retrieval + tools + orchestration + evaluation), not from any single model.

4.2 Coding Agents Debut: Devin and SWE-agent ​

In March 2024, Cognition released the demo video for Devin, billed as "the first AI software engineer," solving real issues end-to-end on SWE-bench — the drama of the demo and the ensuing "did the video overstate the capability?" controversy pushed coding agents into the mainstream spotlight for the first time. In April, Princeton open-sourced SWE-agent (NeurIPS 2024 paper), showing that a well-designed Agent-Computer Interface (ACI) lets GPT-4 reliably solve about 12% of SWE-bench issues — not a high score, but the route was validated. Detailed teardowns in the Devin case and the SWE-agent case.

4.3 Multi-Agent Framework Wars and Computer Use ​

2024 was also the warring-states era of frameworks: Microsoft's AutoGen (first release September 2023, iterated through 2024), CrewAI (went viral in early 2024), and LangGraph (0.1 in early 2024, modeling agent orchestration explicitly as a state graph) each gathered followings, and the debate over "is multi-agent a real need or over-engineering" ran all year. The lessons of that brawl were later summarized by Anthropic's Building Effective Agents (December 2024): most scenarios are fine with a simple workflow — don't reach for multi-agent to show off. See Choosing a Framework and Multi-Agent Architectures.

On October 22, Anthropic shipped computer use alongside the new Claude 3.5 Sonnet: the model reads screenshots directly, moves the mouse, and types — operating arbitrary software the way a person does. Its OSWorld benchmark score at the time was only about 15%, far from practical, but the direction was momentous — the agent action space expanded from "call APIs" to "operate anything with a GUI," paving the way for 2025's Operator and Manus-style products.

In September, OpenAI released o1, making "test-time compute" an explicit training objective: the model first generates a long chain of thought, then answers. The arrival of reasoning models filled the last gap in the agent engine — planning and self-correction over long horizons.

4.4 MCP: Standardizing the Tool Ecosystem ​

On November 25, 2024, Anthropic released and open-sourced the Model Context Protocol (MCP): an open protocol letting any LLM application connect to data sources and tools in a uniform way, with a client-server architecture and inspiration explicitly drawn from the Language Server Protocol (LSP). Adoption was slow at first — the real explosion came after OpenAI announced support in March 2025. Historically, though, MCP ended the fragmented era of "every framework has its own tool interface"; details in Tools & MCP.

5. The Year of the Agent (2025–2026): from Demos to Productivity ​

If 2023's keyword was "wonder" and 2024's was "consolidation," 2025–2026's keyword is just one word: agentic — promoted from a technical term to the center of the industry's entire narrative.

5.1 Reasoning Models Light the Fuse ​

On January 20, 2025, DeepSeek released and open-sourced R1, reproducing o1-class reasoning at a fraction of the cost and publishing the RL training details. R1's impact was twofold: reasoning stopped being the privilege of a few closed vendors — the cost of the agent "brain" dropped sharply — and it crystallized an industry-wide consensus that reasoning models are agent engines. That same month, OpenAI released Operator, a consumer-facing agent built on computer-use technology that can autonomously operate a browser to order food, shop, and more.

5.2 Deep Research: the Research-Agent Category Is Born ​

On February 2, 2025, OpenAI released Deep Research: give it a research question and the agent autonomously browses dozens to hundreds of web pages, cross-validates, and outputs a long cited report, shattering records on the "Humanity's Last Exam" benchmark. Google (Gemini), Perplexity, and others quickly shipped equivalents. Deep Research's significance: it established the product shape of "long autonomous runs (tens of minutes) + a tangible deliverable" — the unit of agent work shifted from "turns" to "tasks."

5.3 The Coding-Agent Arms Race: 2025's Biggest Winner ​

Looking back, the dense run of coding-agent launches in 2025 was the most commercially successful wave in agent history:

  • February 24: Anthropic released Claude Code (research preview) alongside Claude 3.7 Sonnet — a coding agent that lives in the terminal, reading and writing the codebase, running tests, and driving git directly.
  • April: OpenAI shipped the open-source Codex CLI; in May it launched cloud Codex — a software-engineering agent working on multiple tasks in parallel inside isolated cloud environments and submitting PRs directly.
  • June: Google open-sourced Gemini CLI; in August Alibaba released Qwen Code; Chinese vendors (Tencent CodeBuddy, ByteDance Trae, and others) followed across CLI and IDE agents.
  • September: OpenAI released GPT-5-Codex, optimized specifically for agentic coding.

The business numbers validated the track: by public reporting, Claude Code reached roughly a billion dollars in annualized revenue within about half a year of launch, becoming Anthropic's fastest-growing product; Codex staged a comeback in early 2026 and became a strategic priority at OpenAI. IDE-family products like Cursor and GitHub Copilot also went fully agentic (background agents, cloud tasks). Why coding? Because code tasks carry a built-in verifier (compilation, tests) — errors can be caught and the process audited, making it the domain where humans most easily feel safe delegating. Deep dive in the Claude Code case.

5.4 Manus and China's General-Agent Moment ​

In early March 2025, the Chinese team Monica (Butterfly Effect) demoed the general agent Manus: operating a browser and tools autonomously inside a cloud virtual machine to finish long tasks like making slides, analyzing stocks, and organizing data. Invitation codes briefly traded at absurd prices, making it the signature domestic AI story of 2025. Manus turned "general agent" from a concept into a product ordinary people could feel, and pushed the "agent + cloud sandbox" product shape onto the main stage. Registration opened in May, and China's majors (ByteDance's Coze Space, Baidu's Xinxiang, Alibaba, and others) flooded into the general-agent lane soon after. See the Manus case.

5.5 The Protocol Layer: MCP vs. A2A and the Standardization Fight ​

2025's most important agent-infrastructure progress happened at the protocol layer:

  • March: OpenAI announced that the Agents SDK would support MCP — just four months after Anthropic's release. MCP became the de facto standard from that point, and community MCP servers numbered in the thousands within the year.
  • April 9: Google announced the A2A (Agent2Agent) protocol at Cloud Next with 50+ partners, solving agent-to-agent interoperability — complementary to MCP (which connects agents to tools). On June 23, Google donated A2A to the Linux Foundation.
  • December 9: the Linux Foundation announced the Agentic AI Foundation (AAIF): Anthropic donated MCP, OpenAI donated AGENTS.md, Block donated goose, with founding members including Anthropic, OpenAI, Google, Microsoft, AWS, and others. With that, the core agent protocols completed neutral stewardship — an echo of Kubernetes being donated to the CNCF.

5.6 2026: the Deep End ​

Entering 2026, the industry's focus shifted from "shipping new agents" to "governing agents": protocol specs went through major revisions (MCP's July 2026 release was its largest systematic revision ever), and observability, evaluation, security, and cost became real pain points for engineering teams — exactly why the advanced architecture chapters of this site exist. The Claude Code vs. Codex rivalry turned into a product-shape race of "parallel multi-agent + background automation"; Agent Skills (introduced by Claude Code in October 2025, an open standard by December) became a new vehicle for distributing agent capabilities, adopted by the major coding tools in early 2026. The industry consensus sharpened: model capability keeps climbing, but the differentiation increasingly lives in harness engineering, context engineering, and evaluation systems.

"Agentic" also completed its journey from adjective to industry narrative in this period: it's everywhere in earnings calls, product launches, and job postings. That heat deserves caution — the 2023 AutoGPT lesson says narrative peaks tend to lead capability delivery by a year or two. The difference this time: coding agents have produced auditable revenue, so the track has at least one foot on solid ground. For job seekers, that means 2026's agent roles are both real and crowded, and the differentiation lies precisely in the "directions with verifiers" described in Pattern Three below — see the Knowledge Map for a breakdown of the skill stack.

The discipline of reading history

The 2025–2026 material above reflects public reporting as of August 2026. Agent product data (revenue, market share) mostly comes from vendor statements or secondhand reporting; verify against primary sources before citing it in résumés, reports, or investment materials.

6. Sixty Years, One Table ​

DateEventHistorical significance
1966ELIZA releasedPrototype of the conversational interface; early warning of the "ELIZA effect"
1966–72Shakey robot (SRI)Ancestor of the sense–plan–act loop
1970sMYCIN and other expert systemsThe peak and the bottleneck of hand-injected knowledge
1987Bratman articulates BDIAgent mental states theorized
1995Rao & Georgeff; Wooldridge & Jennings papersBDI operationalized; the agent concept system takes shape
1992TD-GammonFirst proof that self-taught beats hand-crafted rules
2016.03AlphaGo defeats Lee SedolSuperhuman agent via deep RL + search
2020.05GPT-3 paperIn-context learning; prompt engineering is born
2022.01Chain-of-Thought paperReasoning can be "drawn out"
2022.03InstructGPT paperRLHF teaches models to follow instructions
2022.10ReAct paper; LangChain open-sourcedThe unified reason+act loop; the framework era begins
2022.11.30ChatGPT launchesEvery precondition finally in place
2023.03GPT-4; AutoGPT open-sourcedAn engine that's finally strong enough; the autonomous-agent phenomenon explodes
2023.04BabyAGI; Generative AgentsThe minimal agent loop; the memory-stream architecture
2023.06.13OpenAI function callingTool calling becomes structured and production-grade
2023.10SWE-bench releasedCoding agents get a scoreboard
2024.03–04Devin demo; SWE-agent open-sourcedThe coding-agent route is validated
2024.09OpenAI o1 releasedTest-time compute becomes an explicit objective
2024.10.22Claude computer useThe action space extends to any GUI
2024.11.25MCP releasedStandardized tool connectivity
2025.01.20DeepSeek-R1 open-sourcedReasoning capability democratized
2025.02Deep Research; Claude Code launchThe research-agent category; the terminal coding agent
2025.03Manus launches; OpenAI adopts MCPGeneral agents break out; MCP becomes the de facto standard
2025.04–06A2A announced, then donated to the Linux FoundationAn agent-to-agent interoperability protocol
2025.05–09Codex cloud, Gemini CLI, GPT-5-CodexThe coding-agent arms race goes white-hot
2025.12.09AAIF founded; MCP/AGENTS.md donatedAgent protocols placed under neutral stewardship
2026The engineering deep end: evals, observability, Skills, parallel multi-agentCompetition shifts from models to systems engineering

7. Three Patterns from History ​

Pattern One: concepts lead engineering by a decade; engineering waits for an engine. BDI theory was complete in 1995 and waited nearly thirty years for a smart enough executor; AutoGPT's architecture went viral in 2023 and waited two years for strong enough reasoning models. When you meet a "new concept," ask first: is it genuinely new, or are old ideas finally getting a new engine? Most of the time it's the latter — and that's nothing to be embarrassed about; it's a predictable window of opportunity.

Pattern Two: every boom ends in standardization. Function calling standardized tool invocation (2023), MCP standardized tool connectivity (2024–25), A2A standardized agent-to-agent interconnection (2025), and AGENTS.md/Skills standardized the distribution of agent knowledge and capabilities (2025–26). The chaos period is the framework developer's battlefield; once standards land, value migrates up to applications and down to infrastructure. For the individual learner: learn the protocols and standards (they live long), be cautious about framework-specific abstractions (they live short).

Pattern Three: adoption order is decided by "verifiability." Agents boomed first in coding (compilers and tests exist), then in research and analysis (citations can be checked), while the "fully autonomous life assistant" has yet to truly materialize (no verifier, high error costs). To judge whether an agent direction is about to take off, don't ask "are the models smart enough" — ask "can this task's results be verified cheaply." The same rule applies to picking projects and job offers — see The Job Landscape.

References ​