What "Agentic" Actually Means

By the middle of 2026 “agent” has been stretched until it means almost nothing. A newsletter calls a scheduled cron job an agent. A landing page calls a chatbot with a system prompt an agent. A demo calls a single API call wrapped in a for loop an agent. When a word covers everything, it stops telling you anything — and worse, it hides the one distinction that actually changed my working day.

So before this series gets into terminals, feedback loops, and shipping real features, I want to draw a clean line. Not because taxonomy is fun, but because the difference between agentic and not is the difference between a tool that answers you and a tool that goes and makes something true. That difference shows up in how the work feels, not just in the marketing.

Three things we keep calling the same word

Most of what gets labelled “AI coding” in 2026 is one of three things, and they are not the same animal.

Autocomplete. It predicts the next token given what’s on screen. Copilot’s ghost text, your editor finishing a function signature. It’s genuinely useful and I use it all day — but it has no goal beyond the next few tokens, no tools, and no loop. It can’t run your tests. It doesn’t know whether what it suggested worked. It suggests; you decide.

Chatbot. Turn-based question and answer. You ask, it answers, and between your turns nothing happens. This is most of what people mean when they say “I used ChatGPT for it” — the thing that hit 100 million users and changed how everyone writes. You’re still the one moving the work forward. The model is a very well-read colleague who can’t touch the keyboard.

Agent. Has a goal, a set of tools it can actually use, and a loop: it acts, observes what happened, and decides the next step based on the result. It reads a file, runs a command, sees the command fail, reads the error, and adjusts — without you mediating each hop. The part that matters most is the quietest: it has to judge when the work is done.

You can feel the line in one sentence. With autocomplete and a chatbot, the verb is “write code for me.” With an agent, the verb is “go make this true, and tell me when it’s done.”

The three ingredients

Strip the hype off and an agent is three things bolted together. Take any one away and you fall back to a chatbot.

1. Tools. It can do things, not just describe them — read and write files, run shell commands, hit an API, query a database. A model that can only talk is a chatbot no matter how good the talk is. (This is exactly the problem MCP set out to standardise: a common port so a model can reach real tools instead of a bespoke integration each time.)
2. A loop. The output of one step becomes the input to the next. The agent isn’t guessing once and hoping — it’s reacting to ground truth, over and over, until the goal is met or it gives up and asks. No loop, no agency; just a single shot with extra steps.
3. Permission to act. Tools plus a loop means it can change your repo, your database, your deploy. Which immediately raises the only question that matters in practice: how much do you let it do without asking? We’ll spend a whole post on that later in the series, because it’s where trust is won or lost.

Why this isn’t 2023 again

If you were paying attention three years ago, this all sounds suspiciously familiar. AutoGPT and the round-one agent hype promised exactly this — autonomous agents that decompose a goal and just go — and it face-planted. So why is 2026 different, and not just louder?

The 2023 toys failed structurally, and two components changed at once:

• The reasoning got real. The o1/R1 generation can actually plan multi-step work and, crucially, recover from its own mistakes. The 2023 models narrated plans they couldn’t execute and, on hitting an error, looped into confident mush. A current model hits the error, diagnoses it, and changes course.
• The environment got real. This is the bigger one. The 2023 agents hallucinated their world — they “believed” a command succeeded because nothing told them otherwise. A modern coding agent’s world is your actual repository: it greps real files, runs your real test suite, and gets ground-truth feedback on every step. Verifiable surroundings discipline a model the way a failing test disciplines a junior dev. You can’t bluff a red build.

That second point is the whole series in miniature, and it’s why a month with CLI coding agents felt nothing like the AutoGPT era. The intelligence helps. But the environment is what turns intelligence into reliable work — which is why “designing the feedback loop” gets its own post.

Why it changes the work, not just the tooling

Here’s the part the feature comparisons miss. When the unit of work shifts from “a snippet” to “a goal,” your job shifts with it.

You stop typing the implementation and start specifying the outcome, the constraints, and the checks. You spend less time writing the obvious middle of a task and more time on the two ends: framing it well at the front, reviewing the diff honestly at the back. The skill that compounds isn’t prompt-wording trivia — it’s the engineering judgment to scope a task, give the agent a way to verify itself, and know when the result is actually right.

None of which makes the senior dev optional. If anything it raises the floor on judgment: an agent will happily make the wrong thing true, fast, if you point it badly. The vibe-coding reflex — accept whatever runs, ship it — is exactly the failure mode this series is trying to inoculate against. Agentic engineering done well is more disciplined than hand-coding, not less.

Where this series goes

That’s the line drawn: agentic means tools + a loop + permission to act, with judgment about doneness sitting underneath all three. Everything else here builds on it.

Next up, I take it out of the abstract and into my actual shell — Claude Code in the terminal: setup, the CLAUDE.md project memory that stops me re-explaining context every session, slash commands, and hooks, with the rebuild of this site as the worked example. After that: the feedback loops that keep an agent honest, subagents and parallel work, the guardrails that let me ship to a live box, and finally one real feature start to finish — wins and dead ends included.

Tools, a loop, and the nerve to let it act. Let’s build something with it.