A Short History of LLM Agentic Research (2022–2026)

TL;DR: Each wave of LLM progress hit the next constraint. Prompts hit the reasoning ceiling. Reasoning hit the tool-access ceiling. Tool access hit the reliability ceiling. Reliability hit the context-management ceiling. Agentic coding harnesses like Claude Code are the current wave, and the open question is no longer whether the agent can do the work, but whether you can verify it did the work correctly.

Summary: This is background for anyone who wants to know how we got from “ask GPT-3.5 a question” to “Claude Code plans and fans out subagents across a codebase.” It was originally an appendix to a longer post on working with Claude Code in a large enterprise codebase; it stands on its own as general context, not enterprise-specific.

The agentic interface in Claude Code is recent. It grew out of a short sequence of capability breakthroughs: instruction following, tool use, longer context windows, and harnesses that can keep a model on task across many steps.

One-off prompts (2022). The first wave was single-turn Q&A. GPT-3.5 and Claude 1 could answer factual questions, summarise documents, and write basic code. You asked once; it answered. Small context windows kept sessions shallow.

Chain-of-thought and instruction following (late 2022). Research showed that prompting models to “think step by step” improved accuracy on multi-part problems. RLHF (reinforcement learning from human feedback) made models better at following user instructions. Together, those changes raised the practical ceiling. Latest and biggest models are much better at following instructions, jumps between Haiku 4.5 to Sonnet 4.6 to Opus 4.8 in quality are huge.

Tool use (2022–2023). MRKL (AI21 Labs, 2022) proposed routing between an LLM and discrete expert modules such as calculators or search engines. LangChain then spread the pattern to developers: chains, agents, tool wrappers, RAG pipelines, and memory stores, all wired around raw API calls and prompt engineering. OpenAI formalised tool use with structured function calling in June 2023. The model stopped being only a text generator and became a reasoning engine that could reach out.

Multi-step and the agentic arc (2023). ReAct (reason + act) formalised the plan–execute–observe loop. AutoGPT made autonomous multi-step execution visible to a wider audience. Reliability was poor because errors compound over many steps, but the paradigm was established. Tool calls, not just tokens, were now first-class outputs.

Context window and the haystack problem (2023–2024). Windows grew from 4K to 200K tokens and beyond. The question became whether models could use all that context, or mostly the beginning and end. The “lost in the middle” finding showed that models can miss facts buried inside long documents. Context size improved, but context retrieval quality became the harder problem.

Benchmarks (2023–2024). HumanEval measured single-function code generation. SWE-bench went further: fix a real GitHub issue end-to-end across a codebase. Completion rates climbed from single digits to over 50% in two years. The bottleneck shifted from “can the model reason?” to “can the harness keep it on track over many steps and tool calls?”

Benchmarks still need caution. They attract Goodhart’s Law, scaffolding tricks, memorisation, and evaluation-specific optimisation. A good score is encouraging, but it is not the same as reliable performance on your actual codebase.

Reasoning models and standard plumbing (2024–2025). The next gain came from letting models spend more compute before answering. OpenAI shipped o1 (preview September 2024, full release December 2024), then o3 and o3-mini in early 2025; DeepSeek R1 landed in January 2025 and showed the recipe could be reproduced cheaply. These models are trained to produce a long internal chain of thought, which helps most on hard multi-step problems where a single forward pass used to guess. In parallel the plumbing got standardised: Anthropic published the Model Context Protocol (November 2024) so tools, data, and context could be wired to a model through one interface instead of bespoke glue, and Claude 3.5 Sonnet’s computer use (October 2024) pushed tool calls past text and into clicking around a screen. Better reasoning raised the ceiling again, but it also made the harness the thing that decided whether that reasoning got used well.

Agentic coding harnesses (2025–2026). This is where the current generation lives. Claude Code arrived as a research preview in February 2025 with Claude 3.7 Sonnet, then went generally available in May 2025 alongside the Claude 4 models. The pattern spread fast: most labs shipped a coding CLI agent within the year. SWE-bench scores kept climbing as the harnesses improved, not just the models. The Claude 4.x line added the pieces that make long-running work practical: a one-million-token context window, an effort parameter to trade speed against depth, an explicit memory tool, and parallel subagents. By Opus 4.8 (May 2026) a single session can plan work, fan out hundreds of subagents, verify their output against the existing test suite, and report back, enough to carry a codebase-scale migration from kickoff to merge. The model stopped being the bottleneck. Trust did. The open question is no longer whether the agent can do the work, but whether you can verify it did the work correctly.

The other thing that happened by 2026 is that people started shopping around. Once the best models were also the most expensive, the cost and the single-vendor lock-in became hard to ignore, and a wave of model-agnostic harnesses showed up to answer it: terminal agents like OpenCode, Aider, Cline, and OpenHands that wrap the loop around whichever model you point them at, including cheaper or open-weight ones.

In summary each wave found the next constraint. Prompts hit the reasoning ceiling. Reasoning hit the tool-access ceiling. Tool access hit the reliability ceiling. Reliability hit the context-management ceiling. The current generation is working on improving harness as well as the model, but ultimatly trust and reliability becomes biggest issues.

Research Arc

For the mechanics of how Claude Code itself turns this research into a working harness — tools, context, permissions — see Part 1: Claude Code’s Agentic Harness.

Further Reading