Praxon"Agentic" became the most overloaded term in software this year, applied to products that are, architecturally, a chatbot with a longer system prompt and one function call bolted on. If the definition keeps stretching to cover any product with an LLM call in it, the term loses discriminating power entirely, which is unfortunate, because the underlying architectural distinction is a real and useful one.
The working definition we use tracks the original research framing, not the marketing usage: a system is agentic to the degree it determines its own next action from the current state of its environment, rather than following a path a human or a hardcoded script already specified.
Against that bar, most labeled-agentic products fall into one of two categories that aren't actually it:
- A single function call routed by intent classification isn't agentic. The model selects which of a fixed set of tools to invoke, but that's routing, not planning, no different in kind from a decision tree with a language model doing the classification.
- A fixed, pre-defined multi-step pipeline, sometimes literally a directed acyclic graph, where an LLM fills in content at each node isn't agentic either, regardless of how capable it looks strung together. The control flow was authored by whoever wrote the pipeline. The model is doing generation at each step, not deciding the sequence of steps.
- The actual pattern, closer to what the original ReAct formulation (Yao et al., 2022) described, is a loop: reason about the current state, act, observe the real result, and revise the plan when the outcome diverges from what was expected. The tool calls aren't the defining feature. The closed feedback loop is.
The distinction has direct engineering consequences. A fixed pipeline with LLM-generated content at each step is deterministic in structure and straightforward to test, which is exactly why most production systems should stay pipeline-shaped whenever the task doesn't genuinely require open-ended planning. A true agentic loop is more capable on open-ended tasks but inherently less predictable, and that unpredictability is what demands the guardrails, escalation thresholds, and tracing that a fixed pipeline can mostly skip.
The recurring failure mode is applying the label to sound more sophisticated, then being caught without the safety infrastructure the architecture actually requires. Granting a system autonomy over its own next action means designing explicitly for the case where it chooses wrong, not adopting the term because it's what the market currently rewards.
Most tasks don't need a fully agentic loop. They need a well-scoped pipeline with a language model doing the parts language models are genuinely good at. That's not a lesser architecture. It's usually the correct engineering call, and a deterministic pipeline is far easier to explain to whoever has to sign off on trusting the system than "trust the loop."