What 'Agentic' Actually Means vs. the Marketing Use of the Word

“Agentic” gets attached to products that range from a single prompt template to a genuinely autonomous multi-step loop, which means the word has stopped reliably telling you anything. There’s a real, useful distinction underneath the marketing — it’s just not the one most landing pages are making.

The line that actually matters: who decides what happens next

A script that calls an LLM once and returns the result is not agentic, no matter how good the prompt is:

# not agentic — one call, no decision loop, the sequence is fixed by the code
def summarize(text):
    return llm_call(f"Summarize this: {text}")

An agent is a system where the model, not your code, decides what happens next at each step, based on what it learns along the way:

# agentic — the model decides which tool to call, in what order, and when to stop
def agent(task):
    messages = [{"role": "user", "content": task}]
    while True:
        response = llm_call(messages, tools=available_tools)
        if not response.tool_calls:
            return response.content  # model decided it's done
        for call in response.tool_calls:
            result = execute(call)  # model decided which tool and what arguments
            messages.append(tool_result(call, result))

The difference isn’t “does it use an LLM” or “is it impressive” — a single well-crafted prompt can produce a more impressive-looking output than a genuinely agentic loop doing something mundane. The difference is whether control flow is fixed in your code or decided by the model at runtime.

Where the marketing use of the word breaks down

A few patterns that get called “agentic” and mostly aren’t, by the definition above:

• A chatbot with a system prompt. Answering questions conversationally isn’t a decision loop — there’s no tool call, no multi-step plan, no runtime branching the model controls. It’s a well-prompted single call, repeated per turn.
• A fixed pipeline with an LLM step in it. “Extract data, then classify it, then format the output” — if that sequence is hard-coded and the LLM just fills in each step, that’s an LLM-powered pipeline, not an agent. Nothing about which step runs next was the model’s decision.
• RAG (retrieval-augmented generation). Retrieving relevant documents and stuffing them into a prompt is a fixed two-step process. It’s genuinely useful, and it is not, by itself, an agent — unless the model is also deciding whether to retrieve, what to search for, and whether one search is enough, at which point it’s crossed into the loop this article is describing.

None of these are bad systems for being non-agentic — a fixed pipeline is often more reliable and easier to debug than a genuine agent loop, precisely because you control the sequence instead of the model. The problem is only the labeling.

Why the distinction is worth defending

Once you’re using “agentic” to mean “the model controls what happens next,” a practical question falls out immediately: how much control, over how many steps, before you need the safeguards a real agent loop requires — the permission boundaries from the destructive-actions piece, the memory patterns from why agents forget things, the debugging discipline from the hallucinated tool-call field guide. A fixed pipeline with an LLM step doesn’t need any of that — there’s no autonomous decision-making to bound. Calling it “agentic” anyway is how teams end up either over-engineering a simple pipeline with unnecessary safety infrastructure, or under-engineering a genuine agent because it got scoped like a chatbot.

The word is worth using precisely for exactly one reason: it tells you which set of problems you’re actually signing up to solve.