Topics

On this page

What is Agentic AI

Agentic AI is an AI system that pursues a goal by planning, selecting and executing a sequence of actions with limited human supervision. It combines language model reasoning with external tools, working memory and feedback from intermediate results to complete multi-step tasks.

Goal orientation: It receives a desired outcome rather than a fixed script and determines the steps itself.
Tool use: It acts through tools, which are functions or APIs such as a log search or a deployment command.
Planning: It decomposes a goal into ordered sub-tasks and revises that plan as new observations arrive.
Bounded autonomy: It selects its own next action but pauses for human approval before risky or irreversible operations.
Distinction from generative AI: A large language model (LLM) alone generates one response, whereas agentic AI continues acting until the goal is achieved.

The agentic AI loop for an on-call incident

For example, given the goal "Investigate the spike in 5xx errors on the checkout service", an agentic system queries logs, metrics and deployment history, then proposes a remediation.

Key Characteristics of Agentic AI

Autonomy: The system selects each subsequent action itself, within permissions set by the engineering team.
Planning: It decomposes a goal into dependent sub-tasks and orders them, as described in planning in AI agents.
Memory: It retains earlier observations so that later decisions can reference them, as explained in memory in AI agents.
Adaptation: It revises its plan when a tool fails, times out or returns an unexpected result.
Human oversight: It escalates to a person when a policy, a risk threshold or an ambiguous result requires it.

How Agentic AI Works

The agentic AI loop is an iterative control cycle that runs around one or more AI agents. A common implementation is the ReAct pattern, which alternates explicit reasoning steps with tool actions.

Goal specification: The system receives an objective together with its constraints, such as which actions require approval.
Context gathering: It collects relevant information, often through RAG, which retrieves documents such as a runbook.
Planning: The model selects the next action from the goal, the available tools and prior observations.
Execution: It invokes a tool, such as a metrics query, with specific arguments.
Observation: It parses the tool result and appends it to working memory.
Re-planning: It retains or revises the plan, then returns to the planning step.
Termination or escalation: It stops when the goal is met, a policy requires a person, or a step limit is reached.

Larger deployments distribute work across multi-agent systems, where orchestration, the coordination of several agents by a controller, assigns sub-tasks. Frameworks such as LangGraph, CrewAI and the Claude Agent SDK provide this loop as reusable components.

Example: An On-Call Incident Agent in Python

The program below runs the agent loop on two incidents, with a rule-based planner standing in for the LLM.

Python

# A toy on-call incident agent. Standard library only, fully deterministic.
# The planner is a set of fixed rules that stands in for an LLM.
LOGS = {  # fake log store
    "email-worker": "OutOfMemoryError in worker-3, heap at 98%",
    "checkout": "HTTP 502 from payment client since 14:05",
}
METRICS = {"email-worker": "memory rising 2% per minute", "checkout": "5xx rate 12% (normal 0.2%)"}
DEPLOYS = {"email-worker": [], "checkout": ["v2.4.1 at 14:03"]}

# Tools: plain functions the agent is allowed to call.
TOOLS = {
    "read_logs": lambda s: LOGS[s],
    "get_metrics": lambda s: METRICS[s],
    "list_recent_deploys": lambda s: ", ".join(DEPLOYS[s]) or "none in the last 24 hours",
    "restart_service": lambda s: f"{s} restarted, memory back to 35%",
    "rollback_deploy": lambda s, v: f"{s} rolled back from {v}",
}
NEEDS_APPROVAL = {"rollback_deploy"}  # safety rule: production rollback needs a human

def plan(service, seen):
    # Stand-in for the LLM: choose the next action from what has been observed.
    for tool in ("read_logs", "get_metrics", "list_recent_deploys"):
        if tool not in seen:
            return f"Gather evidence with {tool}.", tool, (service,)
    if "restart_service" in seen:
        return "Memory is normal again.", "finish", ()
    if "OutOfMemoryError" in seen["read_logs"]:
        return "A worker is leaking memory, a restart is low risk.", "restart_service", (service,)
    if DEPLOYS[service]:
        version = DEPLOYS[service][0].split()[0]
        return f"Errors began after {version}.", "rollback_deploy", (service, version)
    return "No clear cause found.", "escalate", ()

def run_agent(service, max_steps=6):
    print(f"Goal: investigate the incident on {service}")
    seen = {}  # short-term memory: tool name -> observation
    for _ in range(max_steps):
        thought, action, args = plan(service, seen)
        print(f"  Thought: {thought}")
        print(f"  Action: {action}({', '.join(repr(a) for a in args)})")
        if action in NEEDS_APPROVAL:
            print("  Observation: held for human approval, on-call engineer paged")
            return
        if action in ("finish", "escalate"):
            print("  Observation: incident summary posted to the team channel")
            return
        seen[action] = TOOLS[action](*args)
        print(f"  Observation: {seen[action]}")
    print("  Step limit reached, paging the on-call engineer")

run_agent("email-worker")
run_agent("checkout")

Output:

Example

Goal: investigate the incident on email-worker
  Thought: Gather evidence with read_logs.
  Action: read_logs('email-worker')
  Observation: OutOfMemoryError in worker-3, heap at 98%
  Thought: Gather evidence with get_metrics.
  Action: get_metrics('email-worker')
  Observation: memory rising 2% per minute
  Thought: Gather evidence with list_recent_deploys.
  Action: list_recent_deploys('email-worker')
  Observation: none in the last 24 hours
  Thought: A worker is leaking memory, a restart is low risk.
  Action: restart_service('email-worker')
  Observation: email-worker restarted, memory back to 35%
  Thought: Memory is normal again.
  Action: finish()
  Observation: incident summary posted to the team channel
Goal: investigate the incident on checkout
  Thought: Gather evidence with read_logs.
  Action: read_logs('checkout')
  Observation: HTTP 502 from payment client since 14:05
  Thought: Gather evidence with get_metrics.
  Action: get_metrics('checkout')
  Observation: 5xx rate 12% (normal 0.2%)
  Thought: Gather evidence with list_recent_deploys.
  Action: list_recent_deploys('checkout')
  Observation: v2.4.1 at 14:03
  Thought: Errors began after v2.4.1.
  Action: rollback_deploy('checkout', 'v2.4.1')
  Observation: held for human approval, on-call engineer paged

Automatic remediation: The email worker shows a memory leak, so the agent restarts it, because a restart is low risk and reversible.
Approval gate: The checkout errors began after deployment v2.4.1, so the agent proposes a rollback and holds it for human approval.
Separation of concerns: In production, an LLM selects each action through tool calling, while the step limit and approval policy remain in deterministic application code.

Chatbot vs AI Agent vs Agentic System

	Chatbot	AI agent	Agentic system
Input	A question	A task	A goal
Output	A text reply	One task completed with tools	A multi-step outcome
Incident example	"What does HTTP 502 mean?"	"Summarise the checkout error logs"	"Investigate the spike in 5xx errors on the checkout service"
Human role	Reads each answer	Checks the result	Sets limits and approves production rollbacks

Detailed comparisons appear in agentic AI vs AI agents and agentic AI vs generative AI, and recurring structures in agentic design patterns.

Applications of Agentic AI

IT service management: Resolving routine tickets such as access requests and credential resets.
DevOps incident response: Correlating logs, metrics and deployment history, then proposing a remediation.
Software engineering: Coding agents that modify code, execute test suites and repair failing builds.
Data pipeline monitoring: Detecting failed jobs, diagnosing root causes and rerunning idempotent steps.
Security alert triage: Enriching alerts with contextual data and prioritising them for analysts.

Advantages

Reduced toil: Engineers review proposed remediations instead of repeating diagnostic procedures.
Lower response time: Evidence collection begins within seconds of an alert, at any hour.
Adaptability: The system can pursue an alternative approach when one step fails.
Consistency: Approval policies are enforced identically on every run.

Limitations

Irreversible errors: A misinterpreted signal can trigger a destructive action, so high-risk steps need human-in-the-loop approval.
Cost and latency: Every step requires a model inference call, so long tasks increase cost and completion time.
Security: A log line or retrieved document can carry hidden instructions, known as prompt injection.
Testability: The same goal can produce different execution paths, which requires AI agent evaluation methods.
Accountability: Ownership of each automated decision must be assigned to a named team.

Quick Quiz

Pick an answer to check yourself. Nothing is saved.

Question 1 / 3

1. What makes a system agentic rather than a plain chatbot?
2. In the Python example, what plays the role of the LLM?
3. In the incident example, which action is held for human approval?

Frequently Asked Questions

Is ChatGPT agentic AI?

A chat assistant that answers one message at a time is generative AI. It becomes agentic when it has tools and can plan and run several steps towards a goal, such as reading logs and checking metrics. The setup decides this, not the product name.

What is the difference between agentic AI and AI agents?

An AI agent is one model with tools that runs a loop to complete a task. Agentic AI is the wider approach of building goal-driven systems with some autonomy, and such a system can use one agent or several.

What does agentic AI mean?

Agentic AI means an AI system that acts with agency: it receives a goal, decides its own steps and carries them out with tools. A plain model produces one response and waits, while an agentic system keeps acting until the goal is met or a person must decide.

Is agentic AI safe to use in production?

It can be used safely with clear limits. Give the system only the tools it needs, cap the number of steps and log every action. Require human approval for actions that are risky or hard to undo, such as a production rollback.

Which frameworks are used to build agentic AI?

Common choices include LangGraph, CrewAI and the Claude Agent SDK. They provide the agent loop, tool handling and memory as ready components. A small agent can also be written in plain Python, as the incident example above shows.