AI agents, before they were a thing

Before "agentic AI" was on every conference banner, I was using an early version of CrewAI to get an LLM to read, search and document decades-old COBOL for a financial services company in Paris. Here is what an AI agent actually is, how it worked back then, and why the idea is suddenly everywhere.

This year it is hard to open a newsletter without meeting the word "agentic". Agentic AI, agentic workflows, agentic platforms, agentic everything. Every software company now has agents, and every conference has a keynote about them. If you're new to all this, it can sound as though a brand-new species of AI arrived some time in 2025.

It didn't. The core idea is older, and much simpler, than the marketing suggests. I know because I built with it before it had a name. In the early days of CrewAI, one of the first frameworks for building teams of AI agents, I used it on a project for a financial services company in Paris: getting an LLM to translate and document COBOL, the programming language a surprising amount of the financial world still quietly runs on. To do that, the model had to go and look things up for itself. That, it turns out, is the whole trick.

This piece explains, in plain terms, what an AI agent is, how that early version worked, a practical example you can play with, and how it all connects to the agent boom happening now. No technical background needed. If you'd like the foundations first, there's What is AI, really? and the piece on how LLMs work, but you don't need either to follow along.

In one minute
What an AI agent actually is
The idea An AI agent is an LLM that can use tools, in a loop. It thinks about what to do, uses a tool (search a database, check a calendar, run a calculation), looks at the result, and repeats until the job is done.
Why it matters A chatbot can only answer from memory. An agent can go and fetch what it doesn't know, and actually do things. That's the jump from "answers questions" to "gets work done".
The catch Every step is the model making a decision, so more steps means more chances to go wrong. And an agent is only ever as good as the knowledge it can reach.
Think→ Act→ Look→ Repeat
A few words used in this pieceplain-English glossary
LLM
Large language model. The technology behind ChatGPT, Claude and Gemini. It reads text and writes text.
Tool
Anything the AI can ask the surrounding software to do for it: search, calculate, read a file, send an email.
Context window
How much text the AI can "see" at once. Everything it knows about your task has to fit in there.
Vector database
A database that finds text by meaning rather than exact words. Ask for "interest calculation" and it can find a section of code that never uses those words.
Agent
An LLM that can use tools, in a loop, until a job is done.
Crew
Several agents with different jobs passing work between them, like a small team. CrewAI's word for it.
Framework
Ready-made code for building agents, so you don't start from scratch. CrewAI is one.
01

A language from 1959, and a model that had never seen this code

COBOL was designed in 1959, and a remarkable share of the world's banking, insurance and payments still runs on it. These systems work. Many have worked for decades. The trouble is that the people who wrote them have often retired, the documentation (where it exists) tends to describe the system as it was long ago, and the code itself is enormous, tightly interconnected, and written in a style few modern developers are trained in.

The job was twofold: translate COBOL programs into a modern language, and document what they actually do, in plain words a new team could rely on. An LLM looks perfect for this. It can read code and it can write explanations. And on a single, self-contained program, it does well.

But real COBOL programs are rarely self-contained. A program uses data structures defined somewhere else (in shared files called copybooks), calls other programs, and reads files that yet other programs wrote. To explain what one program does, you often need to know about a dozen others. The model had never seen any of them. It knew COBOL the language. It knew nothing about this codebase.

You couldn't just paste the whole codebase in, either. The amount of text an LLM could take in at once, its context window, was far smaller then than it is today, and a financial institution's codebase is far larger than any window. So the model needed a way to look up exactly the pieces it needed, when it needed them. The codebase went into a vector database, a searchable index of the programs and copybooks, and the model was given the ability to query it.

That last sentence is the whole idea of an AI agent.

02

So what is an agent?

Strip away the marketing and an agent, at least as it was then, is three things: an LLM, some tools, and a loop.

Think of a very well-read consultant locked in a room with no phone, no internet and no files. Ask them anything and they'll answer from memory: often impressively, sometimes confidently wrong. That's a plain LLM. Now give the same consultant a phone, a library card and the key to your filing cabinet, and tell them they're allowed to use all three before answering. That's an agent. Same brain. Very different results.

One detail surprises people. The LLM can't actually press any buttons. It can only write. So when it wants to use a tool, it writes a request in a fixed format, something like search_codebase("CUST-BALANCE"). The framework around it (ordinary code, which CrewAI provided) spots the request, runs the search, and pastes the result back into the conversation. The model reads the result and decides what to do next: another search, a different tool, or a final answer.

That cycle (think, act, look at the result, repeat) has a name in the research literature: ReAct, short for "reasoning and acting", from a 2022 paper. Nearly every agent you'll hear about today, however sophisticated, still runs some version of it. Step through one below. The COBOL is invented, but the shape of the problem is real.

Demo 01 · Watch an agent thinkpress next step · then try it without tools
Document a COBOL program the model has never seen
The task and the code are below. The highlighted names are used here but defined somewhere else in the codebase. With tools, the agent can search for them. Without tools, it's a plain LLM answering from memory.
The task
Document what program INTCALC does, in plain English.
The code it was given (an excerpt)
PROCEDURE DIVISION. PERFORM READ-ACCOUNT. COMPUTE WS-INTEREST = CUST-BALANCE * WS-RATE / 365. PERFORM WRITE-ACCRUAL.
Press next step to start the agent.
0Steps
0Facts looked up
0Things guessed
Each round: the model writes what it's thinking, asks for a tool, and reads what comes back. It stops when it decides it knows enough.

Look at the two answers side by side. The plain LLM's answer sounds perfectly reasonable, and that's the danger: it guessed that the rate was monthly, and it was wrong. It also missed the leap-year issue entirely, because spotting that required going and checking. The agent's answer is less fluent and far more useful, because every claim in it came from somewhere.

03

How CrewAI organised it

CrewAI appeared as an open-source project in late 2023, and its central idea was charmingly human. Instead of programming an agent, you describe it, much like writing a job posting.

Each agent gets a role, a goal and a backstory, plus the tools it's allowed to use. You then write tasks, each with a description and what a good result should look like, and assign them to agents. Put the agents and tasks together and you have a crew. Finally you choose a process: sequential, where tasks run one after another and each passes its output to the next, or hierarchical, where a manager agent hands out the work and checks it.

The backstory sounds like a gimmick. It isn't quite. LLMs respond strongly to framing, so an agent told it has spent thirty years maintaining banking systems tends to write in a more careful, more domain-aware way than one told nothing at all. You are, in effect, prompting with a character. Here is a simplified version of how you might set up a crew for a job like the COBOL one.

Figure · A crew for COBOL modernisationsimplified
COBOL analyst
GoalWork out exactly what each program does, and what it depends on.
BackstoryThirty years maintaining banking systems. Trusts nothing they haven't checked.
tools: codebase search
→
Modernisation engineer
GoalRewrite the logic in a modern language without changing what it does.
BackstoryHas migrated legacy systems before. Obsessed with edge cases.
tools: codebase search
→
Technical writer
GoalExplain each program in plain English for a team that has never seen it.
BackstoryWrites documentation people actually read.
tools: none needed
Process: sequentialeach agent's output becomes the next one's starting point
For the curious: it really was about this short
analyst = Agent(
    role="COBOL analyst",
    goal="Work out exactly what each program does",
    backstory="Thirty years maintaining banking systems",
    tools=[codebase_search],
)
document = Task(
    description="Document what program INTCALC does",
    expected_output="A plain-English summary, with sources",
    agent=analyst,
)
crew = Crew(agents=[analyst, engineer, writer],
            tasks=[document, translate, write_up],
            process=Process.sequential)
crew.kickoff()   # ...and off it goes
A real setup needs much more than this: review steps, error handling, and a lot of tuning. But the core really is a handful of job descriptions and a to-do list.
04

The hard part was never the agent. It was the knowledge.

There was no established playbook for any of this yet. But of everything involved, the part that was genuinely, stubbornly hard was knowledge: making sure that when the model searched, it found the right thing, and that the right thing was enough.

COBOL makes this harder than most. Names tend to be short and cryptic (CUST-BAL, WS-AMT-2), the same idea can be called different things in different programs, and the meaning of a program can depend on a copybook three references away. A search that works well on ordinary documents can return a dozen plausible-looking pieces of code and miss the one that matters. When that happens, the agent doesn't know it's missing something. It reasons confidently from whatever it was given.

This is the lesson every agent project since has rediscovered. The model can only reason about what's in front of it. Deciding what goes in front of it is most of the work. The demo below shows the trade-off. Each square is a file in a codebase. Six of them (the gold outlines) are the ones the agent actually needs. The shaded area is what fits in its context window.

Demo 02 · What the model gets to seechange the window · change the strategy
240 files, a small window, six that matter
"Load in order" fills the window with whatever comes first. "Search" uses the vector database to pick the files that look most relevant. Neither is perfect.
in the window needed, and in the window needed, but missing
—Needed files it can see
—Other files crowding in

Today's models have far bigger context windows, and that helps. But notice what the large window does: it gets everything in by also letting in a crowd of things that don't matter, and models get distracted by irrelevant material just as people do. Search gets the essentials into a small window, except for the ones it misses, which the agent never knows about. Every serious agent project ends up spending much of its effort here.

The PAD Economic Analysis tool on this site, built much more recently, is a team of seven specialised agents that search a Project Appraisal Document through a vector database before they do any economics. A different decade of documents, the same shape, and the same hard part.

"The model can only reason about what's in front of it. Deciding what goes in front of it is most of the work."

05

A practical example: an agent that books your trip

COBOL is a niche passion, so here's a problem anyone can picture. You ask an assistant: "Book my trip to the workshop in Niamey on 12 November, and keep it under €1,200."

A plain chatbot can't do this. It can only tell you how you might do it. An agent can, if it has the right tools: a calendar to check you're free, flight search, a currency converter (prices in Niamey are in CFA francs), your organisation's travel policy, and email to send the booking request. Choose which tools this agent gets, and whether it must ask you before acting, and watch how its plan changes.

Demo 03 · Give the agent its toolsswitch tools on and off
"Book my trip to Niamey on 12 November, under €1,200"
Same model, same request. The only thing that changes is what it's allowed to use.
Tools
Safety
—Facts looked up
—Guesses
—Acted without asking
An illustration, not a real booking system. Prices are made up; the exchange rate is the real fixed one (655.957 CFA francs to the euro).

Two lessons fall out of this. First, an agent is only as capable as its tools. Take away flight search and it doesn't stop; it guesses, and its guesses sound exactly as confident as its facts. Second, every tool that makes it more capable also gives it more ways to do something you didn't intend. The email tool is what turns a helpful plan into an action in the world. That's why the "ask me first" switch exists, and why every serious agent product today has some version of it.

06

From a niche framework to the agent boom

When I was using CrewAI, agents were a niche: a handful of open-source frameworks, an enthusiastic community, and a lot of experiments that worked brilliantly in demos and fell over in practice. Today they're the main story in AI. Here's roughly how we got from there to here.

Figure · How agents grew upa short timeline
Oct 2022
ReAct
A research paper describes the think, act, look loop that agents still use.
Spring 2023
AutoGPT goes viral
An LLM let loose in a loop with tools. Thrilling demos, unreliable results.
Jun 2023
Function calling
OpenAI's models are trained to request tools in a reliable format, instead of being coaxed into it.
Late 2023
CrewAI
Teams of role-playing agents, described in plain language.
Shortly after
My COBOL project, Paris
An early crew querying a vector database of COBOL for a financial services company.
Oct 2024
Computer use
Models that can operate a screen, mouse and keyboard, like a person at a desk.
Nov 2024
Model Context Protocol
A shared standard for plugging tools into any AI. Often described as a USB port for AI tools.
2025
"Agentic AI" everywhere
Coding agents, research agents, browser agents. Every major AI lab ships an agent framework.
2026
Agents at work
Agents move from demos into everyday tools, running long, multi-step jobs.

Look at that list and what changed is mostly not the idea. It's the plumbing, and the models. Models are now trained specifically to use tools well, so they pick the right one more often and format their requests reliably. Context windows grew enormously. Standards like the Model Context Protocol mean a tool built once can be plugged into many different AI systems. And models got good enough to stay on track through long, multi-step jobs: writing and testing code, researching a question across dozens of sources, filling in forms on a website.

What hasn't changed is the core. An LLM, some tools, a loop. If you followed the COBOL agent above, you understand the coding agent that writes software and the research agent that reads fifty web pages for you. They're the same machine, with better parts and a much longer leash.

"An agent is an LLM, some tools and a loop. Everything since has been better parts and a longer leash."

07

What the boom hasn't fixed

Knowledge is still the hard part. Bigger windows and better search help, but an agent that silently misses the one document that matters will still reason confidently without it.

Small errors add up. Every step in the loop is the model making a decision: which tool, which search, whether it's done. Suppose each step goes right 95% of the time. That sounds excellent. But a job that takes 20 steps only goes right from start to finish if every step does, and the odds of that are much worse than you'd think. Try it.

Demo 04 · Small errors add updrag the sliders
How often does a long job go right from start to finish?
Each dot is one run of the same job. Gold means every step went right. Red means at least one step went wrong somewhere along the way.
95%
20
—
This is simple multiplication: 0.95 × 0.95 × … twenty times. Real agents can sometimes notice a mistake and recover, which helps. But the arithmetic is why long, unsupervised jobs are so much harder than short ones.

Acting is riskier than answering. A wrong answer can be ignored. A sent email, a submitted form or a deleted file cannot. And agents read whatever they find, including web pages or documents written by someone hoping to steer them. More tools, more reach, more ways for that to matter.

Every step costs time and money. Each turn of the loop is another call to the model. An agent that searches twenty times to answer one question is twenty times more expensive than a chatbot that answers from memory. Sometimes that's worth it. Often a simpler design would do.

Notice that most of these come back to the same thing: at every step, a model built to write is being asked to make a small decision. Which tool? Is this result good enough? Am I done? That turns out to be a problem worth a piece of its own, and it's the subject of next month's essay on Jev, a model built to make exactly those decisions.

08

The short version

Before it was a thing, an agent was just a sensible way to let an LLM look things up. It still is. The COBOL project needed a model that could go and find the copybook it was missing, and that is all an agent really is: a model that's allowed to go and find out, and then do something with what it found. The word got bigger. The idea stayed the same size.

So if someone pitches you an "agentic" product, you don't need to understand the keynote. Ask four questions. What tools does it have? What knowledge can it reach? How does it decide when it's done? And what is it allowed to do without asking you first? The answers will tell you more than any demo.

Think, act, look, repeat. Everything else is detail.

Notes
1.CrewAI's concepts (agents with a role, goal and backstory; tasks; crews; sequential and hierarchical processes) are described as they were in its early versions. The framework has grown a great deal since; see its documentation for the current picture.
2.The think, act, look loop comes from Yao et al., "ReAct: Synergizing Reasoning and Acting in Language Models" (2022). The Model Context Protocol was introduced by Anthropic in November 2024; see modelcontextprotocol.io.
3.Details of the client project are kept deliberately general. The COBOL in Demo 01 is invented for illustration and is not from that codebase.
4.All four demos are simulations. The agent steps in Demos 01 and 03 are scripted to show typical behaviour; Demo 02's files and search ranking are made up; Demo 04 is plain arithmetic.