The Age Of Agents

Most people's first experience with AI was a text box. You type something in, something types back. That's it. Useful, sometimes impressive, but basically a very fast conversation.

That framing stuck. And it's wrong — or at least, wildly incomplete.

The chat box is not the technology. It's a window into the technology. The model sitting behind it can do a lot more than have a conversation. Agents are what happens when you stop asking it questions and start giving it things to do.

The difference is whether it has hands

Think about it this way. You have a very smart friend — let's say they know everything about everything. You can call them up and ask them questions. They'll give you great answers. That's the chat box.

But what if you could give that friend a keyboard, a browser, a set of instructions, and tell them: "here's the task, go handle it." They'd start working. They'd look things up, open files, make decisions, run into problems, figure a way around them, and eventually come back to you with a finished result.

That's an agent.

The difference isn't the intelligence. It's whether the AI can act on things or only talk about them. In engineering terms, we call these tools — discrete things the model can reach out and do: read a file, search the web, run a calculation, send an email. The chat box gives the model a mouth. Agents give it hands.

Conversation is stateless. Agents are not.

Here's something that gets glossed over when people talk about chat AI. Every time you open a new chat, the model forgets everything. It has no memory of your previous conversations. You're starting from scratch every single time.

This is fine for casual questions. But it's a disaster for anything that takes more than one step.

Real work is sequential. You read something, then you do something with it, then you check the result, then you adjust. Each step depends on the last. A model that forgets everything between steps can't do that. It's like trying to build a shelf by hiring a carpenter who walks out the door after every single action and comes back with no memory of what they just did.

Agents maintain state — they keep track of what they've done, where they are in a process, and what comes next. They don't need to be reminded every time. The work accumulates.

The loop is the thing

Here is the most important concept, and it is also the simplest once you hear it.

A chatbot runs once. You send a message, it sends one back. Done. If the answer was wrong or incomplete, you try again. The whole system is a single lap around a track.

An agent runs in a loop. It starts on a task, does something, looks at what happened, decides what to do next, does that, looks at what happened — and keeps going until it's done, or until it runs into something it genuinely can't figure out alone. Dozens of laps, automatic. No hand-holding required between each one.

This sounds simple, but the implications are enormous. Tasks that would take a person an hour can happen in the time it takes to pour a coffee. Not because the AI is smarter than the chat version — the brain is the same. Because it's running the process itself instead of waiting for you to push it along step by step.

What it feels like from the outside

You give an agent a goal. Something like: "Go through these 200 spreadsheet rows, look up each company name, find their latest news, and flag any that have had layoffs in the last six months."

With a chat box, this is your entire afternoon. Paste one row, get one answer, copy it somewhere, paste the next row, repeat until you want to cry.

With an agent, you paste the goal once. It starts working. It reads the spreadsheet. It searches each company. It applies the filter. It hands you back a flagged list. You come back in fifteen minutes and it's done.

The agent didn't get smarter. It just got the ability to move through the task rather than only talk about it.

Why this matters more for non-engineers than for engineers

Engineers have had access to this for a while. We just called it "writing a script." You build the loop yourself, in code, and the code executes it. The hard part was always the code.

What's changed is that the code is no longer required. The model can build and run the loop itself, in plain English, based on a description of what you want. The technical barrier — the thing that kept agents in the hands of developers — is mostly gone.

That is the actual news. Not that AI got smarter. That it got accessible. Anyone who can describe a process clearly enough to tell another person how to do it can now describe it clearly enough to give it to an agent.

The chat box is still there. It's still useful. But it was never the ceiling. It was just the door.