Agentic AI is a class of artificial intelligence systems that act as autonomous or semi-autonomous agents: they set or interpret goals, plan and sequence actions, use tools such as browsers, code, or APIs, make decisions based on feedback, and adapt over time to complete tasks. What makes the category architecturally significant is not any single feature but the combination of persistence, autonomy, goal-directedness, and open-world operation. As Ian Foster and colleagues argue in a recent paper and an accompanying opinion piece, those properties expose "abstraction gaps" in the execution environments, programming models, and verification approaches that computer science has relied on for decades—gaps that reactive, prompt-driven systems never touched.

Introduction: Agentic AI as a New Computational Paradigm

Every era of computing has been organized around a dominant abstraction: the process, the service, the virtual machine, the container. Foster's proposal, articulated in the paper "Agency as a New Organizing Abstraction for Computer Science" and a related opinion piece, is that agency may be the next one—the concept around which execution environments, languages, and verification methods will need to be rebuilt.

The claim is deliberately framed as an open question. Whether agency ultimately becomes a durable organizing abstraction, the authors concede, remains unresolved. But they argue that current deployments of agentic systems already expose abstraction gaps that demand systematic attention. In other words, the argument is not that agentic AI is more powerful than prior AI—it is that agentic systems are a different kind of computational entity, one whose behavior does not fit the assumptions built into today's systems software.

Defining Agentic AI: Core Characteristics

Definitions across sources converge on a consistent core. Stanford HAI describes agentic AI as systems that can set or interpret goals, plan and sequence actions, use tools, make decisions based on feedback, and adapt over time—oriented around ongoing task execution rather than turn-by-turn responses, and sometimes operating with minimal human oversight within defined constraints.

Amazon Web Services emphasizes the same traits from an industry angle: "agentic" indicates agency, the ability to act independently but in a goal-driven manner. Such systems make independent contextual decisions, learn from their environment, and adapt to changing conditions. Cisco adds the temporal dimension: where traditional AI, including generative AI, expects humans to own decision-making and planning while the model delivers a single output, agentic AI relies on longer time horizons and executes the necessary steps on its own.

Synthesizing these accounts, four characteristics recur: proactivity (acting before being triggered), goal-directedness (pursuing objectives rather than answering prompts), autonomy (making independent decisions within constraints), and adaptability (adjusting behavior based on environmental feedback). None of these is individually new; their combination in a persistent, continuously operating system is what changes the computational picture.

Reactive AI Systems: The Traditional Model

The baseline against which agentic AI is defined is the reactive system. AWS describes traditional systems as responding only when triggered and following predefined workflows. Cisco similarly characterizes traditional AI as responding to explicit user prompts, with humans orchestrating multi-step workflows and the AI expected to understand requirements and deliver a single output.

This model maps cleanly onto the abstractions computer science already provides. A reactive computation is externally invoked, runs through a defined start-and-finish sequence, consumes resources allocated by someone else, and stops when its task completes. If it fails, the fault is localized: debugging tools and verification methods assume you can trace a linear execution path to the point where things went wrong. Control and correctness are assumed to reside outside the computational component—with the user, the orchestrating program, or the operator.

Architectural Differences: Agentic vs. Reactive AI

The architectural contrast becomes concrete when mapped onto the failure modes Foster's paper documents. Consider resource control: a reactive system consumes resources only in response to external invocation, so existing execution models assume externally invoked computation with reactive resource control. An agentic system initiates actions on its own, producing what the paper calls autonomous resource consumption and unbounded action initiation—a mismatch that calls for proactive resource budgeting, anticipatory constraint enforcement, and isolation for self-directed processes.

Lifecycle management shows the same pattern. Process and service abstractions assume clear start, run, and termination phases. Persistent agents do not: their lifecycles are ambiguous and termination can be costly, which is why the paper calls for lifecycle models for persistent agents, state preservation and transfer, and principled shutdown semantics. The reactive model's episodic shape—invoke, execute, finish—is simply absent.

Agentic vs. Reactive AI: A Paradigm Shift in Computational Abstractions

The table below contrasts the two operational models across four core computational abstractions, showing where agentic characteristics break the assumptions embedded in traditional systems. Use it to trace each agentic property to the abstraction gap it creates: autonomy breaks reactive resource control, persistence breaks episodic lifecycle models, and long decision sequences break localized debugging.

Agentic vs. reactive AI across core computational abstractions, with the abstraction gaps agentic systems create
AbstractionReactive AIAgentic AIAbstraction gap created
Execution modelWaits for direct input; responds only when triggered, following predefined workflowsActs proactively: sets or interprets goals, plans and sequences actions, makes decisions from feedbackExecution models assume externally invoked computation; agentic systems initiate actions on their own, requiring proactive resource budgeting and anticipatory constraint enforcement
Resource controlOperates within externally defined and controlled resource boundariesConsumes resources autonomously, with unbounded action initiationReactive resource control cannot govern self-directed processes; isolation mechanisms for autonomous initiators are missing
System lifecycleDefined, episodic lifecycle tied to a specific task: clear start, run, and termination phasesPersistent, ongoing task execution over long time horizons with ambiguous terminationProcess and service abstractions lack lifecycle models for persistent agents, state preservation and transfer, and principled shutdown semantics
Failure attributionFaults are localized; debugging and verification assume linear executionFailures distribute across long reasoning-action sequences; responsibility blurs at system boundariesExisting tools cannot trace causality across reasoning-action loops or assign end-to-end accountability for autonomous initiators

Read across the rows, the model shows why agentic AI is not merely a more advanced reactive system. Each defining characteristic—autonomy, persistence, goal-directedness—corresponds to a specific assumption in traditional computing that no longer holds, and each gap points to a distinct research need rather than an incremental patch.

The Abstraction Gaps Created by Agentic Intelligence

Foster's central analytical move is to treat these gaps as a coherent family rather than isolated bugs. The paper's catalog extends beyond the four dimensions above. Misplaced responsibility at system boundaries arises because control and correctness are assumed to reside outside the computational component; agentic initiators need new interface contracts and responsibility assignment. Behavior redirected by adversarial content exploits the assumption of a separation between trusted code and untrusted data, demanding trust-boundary tracking and provenance-aware interpretation. And opaque behavior under continuous operation breaks interaction models that assume explicit user commands and episodic execution, requiring oversight interfaces, escalation policies, and scalable human supervision.

These failure modes, the paper argues, become visible—and tractable—only when agency is taken as the organizing concept. That is the paradigm claim in its strongest form: the gaps are not artifacts of immature engineering but structural consequences of running persistent, self-directed computation inside infrastructure designed for episodic, externally controlled processes.

Implications for Computer Science Research

If the framing holds, the research agenda is broad. It spans new execution models with proactive resource budgeting, lifecycle semantics for persistent agents, causal tracing across reasoning-action loops, partial-order explanations for distributed failures, long-horizon accountability mechanisms, and verification methods that can express safety constraints for autonomous action. The opinion piece is candid that this is a proposal, not a settled consensus: whether agency emerges as a durable organizing abstraction for computer science remains an open question.

Two boundaries are worth stating. First, this analysis rests on the framework proposed by Foster and colleagues; it is a prominent lens, not the only way to analyze these systems. Second, the argument concerns concepts and architecture, not products—nothing here evaluates specific commercial agentic platforms, and it is not a guide to building one.

Navigating the New Abstractions of Agentic Intelligence

The decision facing computer science researchers and practitioners is to develop new organizing abstractions, programming models, and verification techniques to effectively manage and build agentic systems. The measurable indicator to watch is the emergence of new programming languages, operating system primitives, or formal verification methods specifically designed for persistent, autonomous, and goal-directed computational entities. When those artifacts start appearing—rather than ad hoc patches to existing process and service models—that will be the evidence that agency has matured from an open question into computer science's next organizing abstraction.

Sources