All articlesThe Chronicle / Geodd

What Is Agentic AI? A Plain Definition with Real Examples

Agentic AI is artificial intelligence that pursues a goal on its own. Instead of answering one prompt and stopping, an agentic system plans a series of steps, uses tools such as APIs and databases, checks the results, and keeps going until the job is done or it needs a human. The word comes from "agency," the capacity to act independently and purposefully. If you have searched "AI agentic," "agentic AI system," or "what does agentic AI mean," this is the idea behind all of them.

No single definition is universally agreed on. Some researchers use "AI agent" for one autonomous program and "agentic AI" for several agents coordinating on a task, while most people use the two terms interchangeably. This article uses the practical meaning. You will see why it matters, how it works, where it is used, how to build a basic system, and what can go wrong.

We run AI inference infrastructure at Geodd, and agentic workloads can be demanding, because a single task can trigger dozens of model calls. That is why the build advice below focuses on the parts that decide whether an agent works in production.

Why agentic AI matters

Agentic AI matters because it moves AI from producing answers to completing work. A chatbot tells you how to fix a billing error. An agentic system looks up the account, checks the refund policy, issues the credit, and confirms the result.

From answers to finished tasks

Many business tasks involve several steps, several systems, and small decisions along the way. They were hard to script with fixed rules and too dull to hand to a person. An agent can take the goal, break it into steps, and call the right tools in order. MIT Sloan gives a simple example: an agent that plans a vacation by reading a traveler's preferences, querying booking sites, and, with payment permission, buying the tickets.

The economics follow from there. Research from MIT Sloan describes the core promise as lower transaction costs, meaning less time spent searching, comparing, and contracting. Agents also work around the clock and can read long documents without fatigue. That makes jobs like screening vendors or comparing insurance quotes cheap enough to run constantly.

Generative AI answers the question you asked, while agentic AI works on the goal behind it.

Agentic AI vs generative AI and chatbots

The three terms overlap, but they describe different levels of independence. The table sets them side by side.

ChatbotGenerative AI modelAgentic AI system
Main jobAnswer a questionCreate content from a promptReach a goal across many steps
AutonomyLow, waits for each messageLow, one output per promptHigh, chooses its own next step
ToolsFew or noneNone by defaultAPIs, databases, code, browsers
MemoryShort chat historyContext windowContext plus stored state
Your roleAsk each questionReview each outputSet the goal and guardrails

Agentic AI builds on generative AI rather than replacing it. A large language model usually acts as the reasoning engine inside the agent. The agentic part is everything wrapped around it: tools, memory, a loop, and rules for when to stop or ask for help.

Is ChatGPT agentic?

A plain chat with a language model is not agentic. It generates a reply and waits for you. The same model becomes part of an agentic system when a product gives it tools, lets it take several steps without your input, and gives it permission to act in other software. Agency is a property of the whole system, not of the model alone.

How agentic AI works

An agentic system works as a loop: it observes, plans, acts, checks the result, and repeats until the goal is met. The model supplies the reasoning at each pass, and the surrounding software supplies the tools and the limits.

The agent loop

Most agentic systems follow the same cycle, whatever framework builds them:

Process diagram of the five steps of the agent loop: perceive, plan, act, check, adapt.

  1. Perceive. Collect the current state from user input, databases, APIs, sensors, or earlier tool results.
  2. Plan. Interpret the goal and decide on the next step or a short sequence of steps.
  3. Act. Call a tool, query a system, write code, or send a message.
  4. Check. Read the result and decide whether it moved the task forward.
  5. Adapt. Update the plan or memory, then loop again or stop and report.

The loop is what makes a system agentic: it acts, looks at what happened, and decides again.

The building blocks

Four pieces make the loop run. The model reasons about what to do next. Tools let it reach outside the text, such as a search API, a database query, or a function in your codebase. Memory keeps the plan and past results available across steps. Orchestration and guardrails set step limits, permissions, retries, and approval points.

A language model alone cannot call an API or watch a data stream. The tools and the loop are what turn text prediction into action.

Single agents and multi-agent systems

A single agent handles a task end to end. Researchers such as MIT's Sinan Aral draw a line here: an AI agent is one autonomous program, while agentic AI is the broader setup in which several agents coordinate on a task. A marketplace where one agent represents the buyer and another the seller is his example.

Multi-agent designs come in two main shapes. In a conductor model, one agent assigns work to simpler agents. This suits sequential workflows but can bottleneck at the conductor. In a peer model, agents work as equals. That removes the bottleneck but can be slower to converge. Neither wins everywhere, so pick the shape that fits the workflow.

Examples of agentic AI systems in use

Agentic AI systems are already running in customer service, software engineering, finance, retail, and physical operations. What they share is a multi-step goal, access to tools, and room to decide.

Common use cases

  • Customer support: an agent reads a ticket, checks the order system and policy, issues a refund or escalates, and writes the reply.
  • Software engineering: an agent reads a failing test, searches the repository, edits code, reruns the tests, and opens a pull request.
  • Finance: banks are exploring agents for fraud detection, loan processing, and compliance checks.
  • Retail: large retailers are building agents for personal shopping, merchandise planning, and problem resolution.
  • Warehouses and logistics: an agent watches camera feeds for abnormal events and can raise an alert or stop a conveyor belt.
  • Supply chain: an agent places supplier orders or adjusts production schedules to keep inventory at target levels.

A warehouse conveyor belt with boxes, an overhead camera, a barcode scanner, and a red stop button.

Notice that the physical examples prove agency is not limited to software. When an agent can trigger something in the world, the cost of a bad decision rises, which matters in the risk section below.

What does not count

A scripted automation that runs the same steps every time is not agentic, because it never decides anything. A single prompt that returns a summary is not agentic either. There is also no official "big four" list of agents. Vendors such as Microsoft, Salesforce, Google, and IBM embed agent features in their platforms, but those are products, not a defined category. Ask three questions of any product: does it pursue a goal, use tools, and choose its own next step?

How to build an agentic AI system

You build an agentic system by starting with one narrow goal, giving the model a small set of tools, and running it in a capped loop with logging and human approval for risky actions. Start small and widen the scope only after it works.

Five steps to a first agent

  1. Pick one goal with a measurable outcome, such as "resolve refund requests under $50."
  2. List the tools it needs and give each the least permission that works. Read-only first.
  3. Choose a model that supports tool calling and holds enough context for your longest task.
  4. Write a capped loop with a maximum step count, timeouts, and a log of every tool call.
  5. Require approval for irreversible actions, then test on realistic and messy cases before widening scope.

Most agent failures come from loose permissions and missing limits, not from a weak model.

Choosing a model for the loop

Agents call the model many times per task, so price per token, context size, and native tool calling decide your choice. These figures come from the Geodd model pages. All three run in US-EAST with zero data retention by default.

ModelInput / 1M tokensOutput / 1M tokensContextTool calling
GPT-OSS-120B$0.039$0.158131.07KYes
GLM 5.3 Flash$0.110$0.4001.05MNo
DeepSeek V4.1 Flash$0.300$1.1001.05MYes

Take a simplified run with 20 model calls, each sending 8,000 input tokens and returning 500 output tokens. That is 160,000 input and 10,000 output tokens. On GPT-OSS-120B it costs about $0.0078. On GLM 5.3 Flash it costs about $0.0216, and on DeepSeek V4.1 Flash about $0.059. At 1,000 runs a day, the last one is roughly $59 a day. Real loops grow their context as they go, so treat these as a floor.

The table also shows a trade-off. GLM 5.3 Flash lists no tool calling, so it suits reasoning and long-document steps inside a loop rather than as the model that calls functions. GPT-OSS-120B is the cheapest option with tool calling, while DeepSeek V4.1 Flash adds the 1.05M context.

A minimal tool-calling loop

Because the API is OpenAI-compatible, the standard OpenAI SDK works. Take the base URL from the model page.

import os, json
from openai import OpenAI

client = OpenAI(base_url="BASE_URL_FROM_MODEL_PAGE", api_key=os.environ["GEODD_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_order",
        "description": "Fetch an order by ID",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order 1042?"}]

for step in range(5):  # hard cap on steps
    reply = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4.1-Flash", messages=messages, tools=tools
    ).choices[0].message
    messages.append(reply)
    if not reply.tool_calls:
        break
    for call in reply.tool_calls:
        result = lookup_order(**json.loads(call.function.arguments))  # your own function
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})

print(messages[-1].content)

The step cap in the for loop is the simplest guardrail you have. Keep it.

Risks and limits of agentic AI

The main risk of agentic AI is that mistakes compound: an agent acts on a wrong assumption, then builds the next step on top of it. Plan for failure before you grant autonomy.

The risks to plan for

  • Unreliable decisions. A wrong action can do more damage than a wrong sentence, such as rejecting a valid loan or sending a bad order.
  • Security. Agents hold credentials and permissions, so a compromised or misled agent can reach real systems.
  • Accountability. You need a named owner for what the agent does, especially with little human supervision.
  • Misaligned goals. An agent that optimizes a poorly chosen metric, like speed or engagement, can hit the number while damaging the outcome.
  • Runaway cost. A looping agent with no step cap can burn tokens quickly.

A padlock, a ring of keys, and a red emergency stop button on a control panel.

Guardrails that hold up

Use least-privilege permissions, step caps, full logs, and human approval for anything irreversible. Define success metrics before launch. MIT Sloan's Katherine Kellogg points out that reclaiming 20% of someone's time is not the same as a 20% labor-cost saving, so measure outcomes, not activity.

Expect the work to be mostly plumbing. In one MIT Sloan study of an agent that flagged adverse events in cancer patients' clinical notes, about 80% of the effort went to data engineering, stakeholder alignment, governance, and workflow integration. Prompting was the small part. Inference reliability matters too, because slow or failing model calls stall a long agentic run and force retries.

Where to go from here

Agentic AI is AI that takes a goal, plans steps, uses tools, checks its work, and keeps going without being prompted each time. It differs from generative AI in autonomy and tool use, and it works best with a narrow goal, tight permissions, and a capped loop. The model you pick and the reliability of the inference behind it decide how well it holds up.

If you are ready to test one, you can try an agent loop on DeepSeek V4.1 Flash through the OpenAI-compatible API, with pricing and integration examples on the model page.

The Chronicle / Bartosz Neuman
Build with Deploypad

Your next idea. A model API away.

Start building with inference and model APIs on Deploypad.

$10 USD Discovery credit

Explore inference and model APIs with $10 in Discovery credit. Enroll in Deploypad and unlock it with your first qualifying automatic top-up. Eligibility and offer details are shown in Deploypad.

Get started on Deploypad
Keep reading

More from Geodd.

All articles