Agentic, defined: what the word actually means

"Agentic" is the most overused word in AI right now, and most people using it can't define it cleanly. We think that's a problem. If the word means everything, it means nothing — and the teams trying to ship real agent projects end up arguing past each other because nobody agreed on what they were building.

Here's our working definition: a system is agentic when it can decide what to do next, take action in the world, and adjust based on what happens. Three parts. All three matter.

Decide, act, adjust — the three-part test

A chatbot that answers questions is not agentic. It responds; it doesn't decide. A workflow that runs a fixed sequence of API calls is not agentic either. It acts, but it doesn't choose the sequence. A model that picks a tool, runs it, reads the result, and picks the next tool based on what came back — that's agentic. The loop is the thing.

This is why "AI agent" and "agentic system" are useful terms and "AI assistant" mostly isn't. An assistant suggests. An agent commits. The difference shows up the moment something goes wrong, because an agent has already taken action by the time anyone notices.

The practical implication: if your system can't take action without a human clicking a button, it isn't agentic. It's a recommender with extra steps. Nothing wrong with that — but call it what it is.

What "agentic AI" means in practice

Agentic AI is the application of this loop to real work. A foundation model from Anthropic or OpenAI provides the reasoning. A set of tools provides the actions. A runtime ties them together. The model reads the user's goal, picks a tool, the runtime executes it, the result goes back to the model, and the model decides what to do next.

That loop is simple to describe and hard to run reliably. The reasoning layer has improved fast — Claude and GPT-class models can plan, reflect, and recover from errors better than they could a year ago. The action layer has not kept up. Agents in production today fail mostly at the action step: the tool didn't exist, the API didn't expose what the agent needed, the auth context was wrong, the call silently broke when the underlying product changed.

This is why we keep arguing that the tools layer is where agent projects actually stall. The reasoning works. The reach doesn't.

Agentic systems vs. agent frameworks

The word "agentic" gets attached to two different things, and conflating them causes confusion.

An agentic system is the full thing — model, tools, runtime, memory, the user-facing surface. It's what your customer sees and what does the work.

An agent framework is one component inside that system — usually the orchestration layer that manages the decide-act-adjust loop. LangChain/LangGraph, the OpenAI Agents SDK, and CrewAI are agent frameworks. They give you primitives for prompting, tool-calling, and state management. They don't give you the tools themselves, and they don't make your product reachable.

This distinction matters because teams adopt a framework and then assume they have an agentic system. They don't. They have a loop with nothing useful to do until someone builds the tools the loop calls. That's usually where projects stall — six weeks into the framework, looking at a list of forty actions the agent needs to take, and realising the API exposes a handful of them.

Why a tight definition matters

We care about this definition because the word is doing real work in procurement and engineering planning right now. Boards are asking CTOs whether the company is "agentic-ready." Vendors are slapping the label on chatbots. Engineering teams are getting asked to build agentic systems without anyone agreeing on what counts.

A tight definition cuts through that. If the system can't decide, act, and adjust, it isn't agentic — and any conversation about making your platform agent-ready should start with what actions an agent could actually take against it today. Usually the answer is a small fraction of what the UI can do, which is the structural problem we keep writing about.

How Pontil fits

The agentic loop only works if the action step works. That's the part most SaaS platforms aren't ready for: the agent can reason about what to do, but the API doesn't expose enough of the product for the agent to actually do it. Rewriting the API takes years. Hand-building connectors product by product doesn't scale.

Tools-as-a-Service is our answer to that gap. We generate tools from the codebase you already have, run them as the authenticated user, and keep them current as the product changes — so the action layer of your agentic system actually reaches what your product can do.

What follows from the definition

If you take the three-part test seriously, two things follow. First, evaluating whether something is agentic is an engineering question, not a marketing one — look at the loop, look at what the system can actually commit to, and stop arguing about the label. Second, the bottleneck on agentic AI right now is not reasoning. It's reach. The models can decide; they just can't act on most of what your product does.

That's the gap worth closing. Everything else is vocabulary.