AI Agents & Agentic AI

When a language model can decide, call tools, and react to the result — instead of just "answering" — we call it an agent. This page explains an agent's components and its working loop.

What Is an AI Agent?

An AI agent is a system that uses a language model as its "decision-making brain," but unlike a plain chatbot, it can: perceive its surrounding environment, break a goal into smaller steps, call a tool, observe the result, and decide the next step based on it — all without human involvement at every step. This ability is called Agentic AI.

Agent vs. a Plain LLM

Agentic AI vs. AI Agent

These two terms are often used interchangeably, but one names a specific thing and the other names an approach/spectrum.

• AI Agent refers to a specific, runnable instance: a single system that combines a language model with tools, memory, and decision logic to autonomously pursue a goal. When you say "I built an agent that tracks orders," you mean that specific instance.
• Agentic AI is a broader term that describes an architectural paradigm, not a specific instance. It indicates how much "agency" an AI system has — how much it can plan, decide, and change its execution path on its own, without human involvement. Agentic AI can include a single agent or several coordinated agents (a multi-agent system); the key criterion is the system's degree of autonomy, not the number of agents.

The Autonomy Spectrum: From a Simple Call to Full Agentic AI

The further down the table below you go, the more control over the execution path shifts from the developer to the model itself:

Why This Distinction Matters

When you call a product "agentic," you're claiming the entire system makes decisions with a high degree of autonomy — not just that it's one agent with a few tools. For instance, the "agentic commerce" architecture that underpins OpenCommerce is exactly an Agentic AI system: several agents (buyer, seller, logistics), each deciding independently and coordinating through protocols like A2A — not simply a single agent with a few extra tools.

An Agent's Core Components

• Core LLM — the reasoning and decision-making engine
• Tools — functions the agent can call (search, an API, a calculation); exactly what MCP standardizes
• Memory — retaining short- or long-term state; covered in detail in Agent Memory Systems
• Planner — the logic that breaks a large goal into smaller steps

The Reason-Act-Observe Loop (ReAct)

One of the most common agent execution patterns is ReAct (Reason + Act): the agent reasons about the next step, takes an action (e.g. calling a tool), observes the result, and repeats this loop until the goal is reached.

Common Agent Architecture Patterns

• ReAct — alternating reasoning and action steps (explained above)
• Plan-and-Execute — the whole plan is designed upfront, then executed step by step
• Reflexion — the agent critiques its own output and corrects it on the next attempt

When a single agent isn't enough, see Multi-Agent Systems.

Code Sample: A Simple Agent Loop

def run_agent(goal, tools, llm, max_steps=5):
    history = []
    for step in range(max_steps):
        thought = llm.reason(goal, history)
        if thought.is_final_answer:
            return thought.answer

        action = thought.next_action           # e.g.: check_inventory(sku="123")
        result = tools[action.name](**action.args)
        history.append((thought, action, result))

    return "No result reached; human intervention needed"

Risks & Guardrails

• Infinite loops — always set a step cap (max_steps)
• Excessive tool access — define each tool with the minimum access it needs (the MCP principle)
• Irreversible actions — for sensitive operations (like payment), add explicit confirmation or an amount limit

FAQ