The Year AI Agents Grew Up

For most of the last few years, "using AI" meant having a conversation. You typed, it answered, you copied the good parts out by hand. Useful, but it was always you doing the work — the model was just a very well-read assistant sitting on your shoulder.

The thing that shifted, and the reason 2025 felt different, is that we started letting models do instead of just say. That's the whole story behind the word everyone is throwing around: agents.

From answering to acting

An agent is, roughly, a model wrapped in a loop. Instead of producing one reply and stopping, it can plan a series of steps, call tools to take actions, look at the results, and decide what to do next. Give it access to a terminal, a browser, and your codebase, and it stops being a chat window — it becomes something closer to a junior teammate who never sleeps.

The capabilities that made this work are unglamorous but important:

• Tool use that actually holds up. Models got reliable at calling functions, reading the output, and not falling apart when something returned an error.
• Longer horizons. Early models lost the plot after a few steps. Newer ones can run for a long stretch on a single goal without forgetting why they started.
• Reasoning before acting. The "think first, answer second" generation of models made agents noticeably more careful — fewer confident wrong turns.

Put those together and you get the demos that went viral last year: an agent fixing a bug across a dozen files, booking travel, or grinding through a backlog of tickets while you sleep.

My honest take: the demo is not the job

Here's where I'll be the skeptic, because I've been burned by enough slick demos to know the pattern.

A demo is a happy path. The real world is mostly unhappy paths — the flaky API, the ambiguous ticket, the thing the agent confidently "fixed" that quietly broke something three modules away. The gap between "watch it do this cool thing once" and "trust it to do this thing unattended a hundred times" is enormous, and that gap is where most of the actual engineering lives.

The hard part of agents was never getting them to act. It's getting them to know when they're wrong — and to stop.

What I've found genuinely valuable is a narrower framing: agents are fantastic at bounded, verifiable tasks. Migrate this pattern across the codebase. Write tests for this module. Refactor this function and prove the behavior didn't change. The common thread is that I can check the result quickly. The moment a task has no cheap way to verify the output, the agent stops saving me time and starts costing me trust.

What this means if you build things

I don't think agents replace engineers. I think they change what the job feels like. Less of my day is spent typing the obvious code; more of it is spent doing three things:

1. Specifying clearly — describing what "done" actually means, because a vague goal produces a confident, wrong agent.
2. Designing for verification — good tests, good types, good guardrails, so the machine can check itself.
3. Reviewing with taste — the bottleneck moves from writing to judging, and judgment is the part that's still very human.

That's not a downgrade. If anything it pushes the work up the stack, toward the parts I actually enjoy.

Where I think this goes next

My bet for the near future isn't one all-powerful agent that does everything. It's lots of small, specialized, boring agents — quietly handling the dependency bumps, the changelog, the first-pass code review, the "did anyone document this?" chores — while humans stay firmly in the loop on anything that matters.

The flashy stuff makes headlines. The boring stuff is what actually ships. And 2025 was the year the boring stuff started working.

That's the breakthrough I care about.