The 75-Year Overnight Success: The Complete History of Agentic AI

Roughly half of the code being pushed to GitHub right now was written — or heavily co-written — by a machine. AI agents pick up real tickets, work for hours without supervision, run the tests, fix their own mistakes, and open pull requests while we sleep. If you blinked somewhere around 2022, this looks like it happened overnight.

It didn't. This "overnight success" took seventy-five years.

And like every good origin story, it is full of false starts, forgotten geniuses, embarrassing public failures, and one quiet insight that changed everything. Let's rewind the tape. All the way.

1950–1990: The Dream Before the Machine

In 1950, Alan Turing asked the question that started it all: can machines think? But hiding right behind it was a more dangerous question — one that would take far longer to answer: can machines act?

Twenty years later, we got the first glimpse. Terry Winograd's SHRDLU (1970) let you type "pick up the red block and put it on the green cube" — and a virtual robot arm actually did it. It parsed your intent, made a plan, and executed it. The world it lived in was a tiny simulated tabletop, but the loop — understand, plan, act — was there, fully formed, half a century early.

Then in 1986, Marvin Minsky dropped a philosophical bomb called The Society of Mind. Intelligence, he argued, is not one big brilliant thing. It is thousands of small, simple agents cooperating — none of them smart on their own, all of them smart together.

Nobody knew it at the time, but Minsky had just sketched the multi-agent architecture running inside your terminal today.

The 1990s: A Recipe Without Fire

The nineties made it official. Researchers gave the software agent its textbook definition — autonomous, reactive, proactive, social — and built entire academic empires around it: BDI architectures (Belief–Desire–Intention), multi-agent systems, "software assistants" that were supposed to book our flights and filter our email.

In parallel, another group was quietly solving the deeper problem: how does an agent learn? Reinforcement learning — Q-learning (1989), the reward signal, trial and error formalized into mathematics — gave us the theory of a machine that improves through experience.

So by the year 2000, we had the full recipe for agentic AI.

What we didn't have was fire. The compute and the data simply did not exist yet. And so the agents stayed trapped in textbooks and toy demos for another two decades — a blueprint waiting for an engine.

2013–2019: Machines Learn to Win

The engine arrived in pieces.

First, DeepMind showed a neural network teaching itself to play Atari games from raw pixels — no rules given, just a score to maximize. Then, in March 2016, came the moment the whole world watched: AlphaGo versus Lee Sedol. In game two, the machine played the now-legendary Move 37 — a move so alien that commentators assumed it was a bug. It wasn't. It was brilliance no human had considered in 2,500 years of Go.

For the first time, a machine displayed something that looked suspiciously like taste.

But these agents were savants: superhuman at exactly one thing, useless at everything else. The missing piece landed quietly in 2017, in a paper with a rockstar title — "Attention Is All You Need." The Transformer architecture. Almost nobody outside the field noticed.

The dream finally had its engine.

2020–2022: Language Meets Action

GPT-3 (2020) proved a single model could follow instructions for almost anything. Its coding sibling Codex became GitHub Copilot (2021) — the first AI tool millions of developers actually used. But let's be honest about what it was: autocomplete. A brilliant, shy copilot that suggested the next line and never, ever touched the controls.

The real unlock came in 2022, and it fit in one acronym: ReAct — Reason + Act.

The insight sounds almost trivial: instead of asking a model for one big answer, let it think, act, observe, and think again. Reason about the problem, run a search or execute some code, look at the result, adjust, repeat. A language model placed inside that loop, with tools in its hands, stops being a text generator.

It becomes an agent.

A few months later, in November 2022, ChatGPT launched — and the entire world suddenly understood what these models were. The stage was set for chaos.

2023: Agent Fever (and the Great Faceplant)

Spring 2023. Two open-source projects — AutoGPT and BabyAGI — asked the obvious question: what if we just give GPT-4 a goal and let it run in a loop, unsupervised?

The internet lost its mind. Hundreds of thousands of GitHub stars in weeks. "The end of jobs" headlines everywhere.

The reality? The agents wandered in circles, hallucinated their own subtasks, forgot what they were doing, and cheerfully burned through API credits like toddlers with a stolen credit card. Almost nothing useful was ever shipped by them.

And yet — 2023 mattered enormously:

• The appetite was proven. Millions of people clearly wanted autonomous AI, even when it barely worked.
• The infrastructure was born. Function calling, tool use, LangChain, AutoGen — the plumbing of the agentic world.
• The imagination expanded. Stanford's "Smallville" experiment put 25 generative agents in a simulated town; they formed relationships and organized a Valentine's party nobody had explicitly programmed.
• The reality check arrived. A new benchmark called SWE-bench tested models on real GitHub issues from real repositories. The best models on the planet solved under 5% of them.

Hype level: 100. Actual capability: 4.8. The gap between those two numbers is where the next three years happened.

2024–2025: The Agents Grow Up

Then the gap started closing — fast.

Devin (March 2024) marketed itself as "the first AI software engineer" and triggered equal parts hype and backlash. Cursor and its siblings moved the agent inside the editor, editing across your whole codebase instead of one line at a time. Reasoning models like o1 learned to think before answering. Anthropic shipped computer use — a model operating a screen, mouse and keyboard like a person — and then, in late 2024, something less flashy and more important: MCP, the Model Context Protocol.

MCP became the USB-C of AI — one open standard connecting any agent to any tool, database, or service. Within months, OpenAI, Google and Microsoft all adopted it. The agents could finally plug into the real world.

And then came the terminal agents — Claude Code, Codex CLI, Gemini CLI — agents that live where the real work happens: reading your codebase, writing, testing, fixing, committing, opening PRs. Andrej Karpathy coined "vibe coding" for the new workflow: describe what you want, watch it appear, never look at the code.

SWE-bench scores stopped crawling and started climbing vertically.

2026: The Revolution Is Live

Which brings us to right now — and the numbers are honestly hard to believe:

• By some estimates, around half of all code committed to GitHub in early 2026 is AI-generated or substantially AI-assisted.
• More than four in five developers already use or plan to use these tools.
• The AI coding tools market has more than doubled in two years, from about $5B to nearly $13B.
• Frontier models now clear 80–95% of SWE-bench Verified — the same benchmark where the best models scored under 5% just three years ago.
• Agents no longer answer in seconds; they work in loops for minutes or hours: plan → execute → verify → fix → repeat.
• Multi-agent orchestration is becoming the default: a lead agent decomposes your ticket and dispatches planner, coder, tester and reviewer sub-agents in parallel.

If 2023 was the year of autocomplete and 2024–2025 the era of AI-powered IDEs, then 2026 is the year of agent engineering. You no longer ask the AI to finish a line. You delegate the ticket.

But there is a catch — and it's the most important sentence in this article: unreviewed AI code ships measurably more bugs and vulnerabilities than human code. The bottleneck has moved from writing software to verifying it. Which is exactly why the discipline I wrote about in Harness Engineering — designing the environment, the constraints, and the verification loops your agents live inside — is quickly becoming the most valuable skill in the industry.

Why This Is a Real Revolution

Not because chatbots got smarter. Because the paradigm flipped: from AI that answers to AI that does.

Code went first for a simple, beautiful reason — it's verifiable. Tests pass or they don't. Programs compile or they don't. An agent can check its own work thousands of times per hour. But the same loop is now spreading outward: research agents that investigate for hours, office agents that operate spreadsheets and browsers, agents in law, science, and design.

Look at how long the thread really is. Turing asked whether machines could think. Winograd made one act. Minsky guessed the architecture. DeepMind proved they could learn. The Transformer gave them a mind, ReAct gave them hands — and now they build alongside us, every single day.

Seventy-five years to become an overnight success.

The machines have finally learned to do the work. Our job — the one that was never automatable — is to be worth listening to: to bring the intent, the taste, and the constraints that turn all that raw capability into something that matters.

The orchestra can play now. Time to learn how to conduct.