What Makes a System 'Agentic'?

What Makes a System 'Agentic'?

Imagine you ask two different AI systems the same question: "I need to understand why our customer churn rate increased last month." The first system—a sophisticated language model with retrieval-augmented generation (RAG)—scans your internal documentation, synthesizes a coherent answer from relevant documents, and delivers it in a well-structured paragraph. The answer is accurate, well-written, and immediately useful. But here's the thing: the system did exactly one thing. It retrieved, it synthesized, it responded, and then it stopped. If the answer required querying a live database, running a statistical analysis, cross-referencing external market data, or generating a visualization to make the trend visible, that first system simply could not help you. It has no mechanism for taking further action.

Now consider what the second system might do. Given the same query, it reasons about what information would actually be needed—perhaps monthly cohort retention tables, a comparison against prior-year seasonality, an analysis of support ticket sentiment from churned customers—and then *goes and gets that information itself*. It writes and executes queries against your data warehouse. It calls external APIs to pull relevant market indices. It generates a chart. It synthesizes all of this into a multi-page report with actionable recommendations. And critically, if something goes wrong—if a query times out, or a tool returns unexpected data—it notices, adapts, and tries a different approach. This system has agency. It doesn't just answer questions; it pursues goals.

The distinction between these two systems is the central topic of this chapter. As AI systems become more capable and as organizations push them into increasingly consequential roles, understanding what separates a reactive question-answering system from a genuinely agentic one is no longer an academic exercise. It shapes architectural decisions worth millions of dollars, determines whether your automation investment delivers a 10% efficiency gain or a 10x one, and determines whether your system fails gracefully or catastrophically when it encounters the unexpected. This chapter builds the mental model you need to reason about that distinction clearly—covering what agency actually means, where systems fall on the spectrum between reactive and fully autonomous, what core components enable agentic behavior, how real-world systems are already exploiting these capabilities, and why conventional machine learning approaches often struggle to deliver on the agentic promise.

Defining Agency: Autonomy, Goal-Directed Behavior, and Environmental Interaction

The word "agentic" has migrated from academic psychology into AI discourse with remarkable speed, and like most borrowed terminology, it carries some conceptual baggage. In psychology, agency refers to an entity's capacity to act independently toward chosen ends. In philosophy, it raises deep questions about intentionality, causation, and what it means to be a doer rather than merely a thing that gets moved around. In AI engineering, the term has settled into something more practical: an agentic system is one that can pursue complex goals over extended time horizons, using whatever means are available to it, without requiring step-by-step human guidance.

That definition contains three load-bearing ideas, and each one is worth unpacking carefully because they map directly onto architectural requirements.

Autonomy means the system can make decisions and take actions without asking permission at every turn. This does not mean the system operates without oversight—responsible agentic systems include bounds, constraints, and human-in-the-loop checkpoints—but within those bounds, the system drives its own behavior. It chooses what to do next based on its assessment of the situation, not because a human explicitly told it to do it. A customer service bot that follows a rigid decision tree branching on user inputs is not autonomous; it is a sophisticated flowchart. An autonomous system is one that evaluates its options and commits to a course of action.

Goal-directed behavior is what separates a system that acts from a system that merely reacts. A reactive system responds to stimuli: it answers the question it was asked, processes the input it receives, completes the task it was explicitly configured for. An agentic system maintains a representation of the goal it is trying to achieve and evaluates whether its current actions are bringing it closer to that goal. When a subgoal fails—when an initial approach doesn't work—the system doesn't simply stop. It reconsiders, formulates a new plan, and continues. This capacity for goal maintenance across multiple steps and extended time horizons is what transforms a system from a sophisticated tool into something qualitatively different.

Environmental interaction is what makes goal-directed behavior actually meaningful. An agentic system must be able to sense and act upon its environment—and in the AI context, "environment" encompasses everything outside the model's own weights: databases, APIs, file systems, web pages, other software systems, physical devices, and human collaborators. A language model that can only produce text is not, by itself, agentic. It becomes agentic when it can take that text generation capability and use it to interact with external systems—to write queries, trigger actions, send messages, or modify files. The environment is not a passive recipient of the system's outputs; it is a dynamic space the system must navigate, monitor, and respond to.

```mermaid graph TD A[Goal: Analyze churn increase] --> B[Assess: What data is needed?] B --> C[Query internal data warehouse] C --> D{Query successful?} D -->|Yes| E[Analyze retention cohorts] D -->|No| F[Try alternative data source] F --> C E --> G[Cross-reference external market data] G --> H[Generate visualization] H --> I[Synthesize findings into report] I --> J{Human review needed?} J -->|Yes| K[Present findings] J -->|No| L[Auto-deliver recommendations] ```

This diagram illustrates what goal-directed, autonomous behavior looks like in practice. The system does not simply output a static answer; it navigates a branching process of querying, analyzing, and synthesizing, with the ability to recover from failures (the "Query successful?" checkpoint) and adapt its approach. Each node represents a decision point where the system evaluates its state and chooses its next action.

The Spectrum from Reactive Systems to Fully Autonomous Agents

One of the most useful conceptual tools for understanding agency is the spectrum. Not every system needs to be fully autonomous to benefit from agentic thinking, and understanding where a given system sits on the spectrum—and where it *should* sit—is essential for making good architectural decisions.

At the simplest end of the spectrum are reactive systems. These systems take an input, process it according to fixed rules, and produce an output. A basic FAQ bot that matches user queries to pre-written answers is reactive. So is a RAG system that retrieves relevant documents and synthesizes a response. These systems have no memory of prior interactions beyond the current context window, no ability to take actions beyond generating text, and no capacity to modify their own behavior based on outcomes. They are, in a meaningful sense, sophisticated lookup systems dressed in natural language.

Moving along the spectrum, we encounter tool-augmented systems. These are reactive systems that have been extended with the ability to call external tools—to execute code, query databases, search the web, or invoke APIs. The language model remains the core reasoning engine, but it is no longer limited to text generation. When prompted with a question, it can decide to call a tool, observe the tool's output, a