A client asked us last month whether we could "add some agentic AI" to their business, and honestly, the question told us more than the answer would have. "Agentic AI" has become one of those phrases that gets attached to everything, which usually means it's either genuinely useful and poorly explained, or mostly marketing. In this case it's a bit of both, so it's worth actually unpacking.
What "agentic" actually means, without the buzzword
A regular AI tool answers a question. You ask, it responds, done. An agentic AI workflow is different in one specific way: it can take a goal, break it into steps, use tools to act on those steps, look at what happened, and decide what to do next — without you writing out every single step in advance. The classic example most people have actually touched by now is an AI coding assistant that doesn't just suggest a line of code, but reads your files, runs a command, sees the error, and fixes it — on its own, across several steps, until the task is actually done.
That loop — do something, check the result, adjust, repeat — is the whole idea. It's not a new concept in computer science. What's new is that a general-purpose AI model can now drive that loop itself, on tasks that used to require a person watching every step.
How this is different from "normal" automation
We've built plenty of traditional automation for clients over the years — the kind where if X happens, do Y, every time, no exceptions. That's still the right tool for a lot of jobs, and it's usually cheaper and more predictable than reaching for AI at all. The difference with agentic workflows is what happens when a situation doesn't match the script. Traditional automation breaks or does the wrong thing. An agentic system can, at least within limits, notice something's off and handle it differently — or flag it for a person instead of blindly pushing forward.
That flexibility is genuinely useful. It's also exactly why these systems need boundaries. An agent that can decide what to do next is also an agent that can decide to do the wrong thing next, faster than a human would have caught it.
Where we've actually seen it work
Setting aside the vendor pitch decks, here's where agentic-style workflows hold up in practice, based on what we've used ourselves and what we've seen work for clients:
- Repetitive, well-defined technical work. Going through a codebase file by file to apply the same kind of fix — the AGP migration work we've written about before is a good example — is exactly the kind of task where an agent checking each file, running the build, and reporting what broke saves real hours.
- First-pass triage. Sorting incoming support tickets or inquiries by topic and urgency, so a person spends their time on judgment calls instead of reading everything from scratch.
- Research and summarization with a human sign-off. An agent pulling together a draft summary of, say, competitor pricing or a technical topic, that a person then reviews and edits — not publishes automatically.
- Monitoring and alerting. Watching for a specific condition (a server metric, a keyword, a status change) and taking a defined action, with escalation to a human when something's ambiguous.
Where we'd still be cautious
This is the part a lot of the hype skips over. We wouldn't hand an agent full autonomy over anything that's hard to reverse, involves real money without a review step, or depends on judgment that's genuinely contextual — a refund decision that depends on the specific customer relationship, legal or compliance-adjacent decisions, anything customer-facing where a confidently wrong answer does real damage before anyone notices.
The pattern that actually works for most small businesses: let the agent do the first 80% of a task — the research, the draft, the repetitive execution — and keep a human doing the last step, the approval. Not because the technology can't go further, but because the cost of an unnoticed mistake is usually higher than the time saved by skipping the review.
How we actually use this ourselves
We've mentioned before that we use AI coding assistants as part of our own development work, and agentic workflows specifically show up in a few concrete places: batch code migrations where the agent works through files and reports back rather than us doing it file by file, drafting content like this blog post which then gets read and edited by a person before it goes anywhere, and flagging likely issues across a codebase for us to actually decide on. Nothing here publishes, deploys, or ships without someone looking at it first. That's a deliberate choice, not a technical limitation.
If you're thinking about this for your own business
Start with one task, not a transformation. Pick something repetitive, well-defined, and low-risk if it goes slightly wrong — not your most sensitive process. See if it actually saves time once you account for the review step, because that step doesn't disappear, it just moves. If it works, expand it. If a vendor tells you their agent needs zero human oversight for anything that matters to your business, that's worth being skeptical of, not impressed by.
The takeaway
Agentic AI is a real, useful shift for a specific kind of work — multi-step, well-defined, repeatable tasks where the cost of a mistake is recoverable. It's not a replacement for judgment on the things that actually need judgment, and anyone selling it as a full replacement for a team hasn't had to clean up after it yet.