Agentic AI: The Next Evolution Beyond Generative AI

Agentic AI: The Next Evolution Beyond Generative AI

If you have been following the machine learning landscape over the past few years, you already know how dramatically generative AI has transformed workflows. Models that produce text, images, code, and audio have moved from research curiosities to production systems used by millions. Yet the industry is already shifting its focus again. The next evolution is *agentic AI* — systems that do not merely generate content, but plan, reason, and act on their own to complete multi-step tasks.

The major vendors tracking this transition — NVIDIA through its developer and AI blogs, OpenAI through its newsroom, Microsoft through its AI research blog, and Anthropic through its product and safety announcements — all point toward a common direction. The value of AI is no longer just in the answer it produces; it is in the work it can autonomously get done. This article explains what agentic AI is, why it matters, and how you can start building your own agents today with free, open tools.

The Shift: From Answering to Acting

Generative AI models are trained to predict the next token in a sequence. Feed them a prompt, and they respond with a plausible continuation. That single capability powers chatbots, copilots, summarizers, and image generators. These are all *reactive* systems: they wait for input, produce output, and stop.

Agentic AI changes the interaction model in a fundamental way. Instead of responding to a single prompt, an agent receives a *goal*, then decides what steps to take to accomplish that goal. It can break the task into sub-tasks, call external tools, retrieve information from the web or databases, write and execute code, inspect the results of its own actions, and iterate until the goal is complete.

An agentic system has a loop, roughly:

1. Observe the current state. 2. Reason about what action to take next. 3. Take that action (e.g., call a tool, run a script, query a database). 4. Observe the result. 5. Repeat until the goal is satisfied.

This is the classic ReAct (Reasoning + Acting) paradigm, and it is the architectural backbone of most modern agent frameworks. The underlying model is still a generative model — but the *system around it* is what makes the AI agentic.

Core Capabilities of an Agent

To call a system "agentic," I look for four capabilities:

**Tool use.** The agent can call external functions — web searches, code interpreters, calculators, REST APIs, file system operations. This is the defining feature because it lets the model affect the real world. The model does not just claim "The weather is sunny in Lisbon"; it calls a weather API and verifies the response.

**Planning.** Given a high-level objective, the agent can decompose it into a sequence of executable steps, reorder them when necessary, and recover from failures mid-plan.

**Memory.** An agent needs both short-term memory (the current conversation and task state) and long-term memory (embeddings of past interactions or knowledge stored in a vector database). Memory lets it maintain coherence over long, multi-hour tasks.

**Self-reflection.** The agent evaluates its own outputs. It can run a test against generated code, see that the test failed, and try again with a different approach. This closes the loop and makes the system genuinely useful for complex tasks instead of a one-shot generator.

When these four capabilities are combined, an AI system becomes something closer to an autonomous co-worker than a chatbot.

Requirements

To follow the practical examples below, you will need a machine with the following:

• **Operating system:** Linux, macOS, or Windows (Windows users should install WSL2 for the smoothest experience).
• **Python 3.10 or newer** — Python is the primary language for agent frameworks.
• **~8 GB of free RAM** — enough to run a modest local language model. For larger models, 16 GB or more is recommended.
• **A free API key** (optional but recommended) if you prefer to use a hosted model instead of a local one. In the examples below, I use a local model via Ollama, so no cloud API key is required at all.
• **Git** (optional, for cloning repositories).

The core software stack we will use:

• **Ollama** — a minimal runtime that runs open-weight models (Llama, Mistral, Qwen, etc.) locally and exposes an OpenAI-compatible API.
• **Python packages:** `openai` (the official SDK, which works not only with OpenAI endpoints but with any OpenAI-compatible server), `python-dotenv` for secrets management, and optionally `langchain` or `crewai` for heavier abstraction. In this article, I will avoid heavy frameworks and show you a minimal agent loop that gives you full visibility into what is happening.

Step-by-Step Installation

All commands below are for a bash shell on Linux/macOS (or WSL2 on Windows).

1. Install Ollama

Ollama is the simplest way to get a local, OpenAI-compatible model endpoint. On Linux and macOS, run:

curl -fsSL https://ollama.com/install.sh | sh

When the installation finishes, start the Ollama server in the background:

ollama serve

Keep that terminal open or run it as a service. The server listens on `http://localhost:11434` by default.

2. Pull a Model

Next, download a capable instruction-tuned model. A good starting point that runs on 8 GB of RAM is `llama3.1:8b`:

ollama pull llama3.1:8b

If you have a smaller machine, `qwen2.5:3b` is also fine. Verify that the model responds:

ollama run llama3.1:8b "Say hello in one sentence."

You should see a short greeting. Press Ctrl+D or type `/bye` to exit the chat interface.

3. Set Up the Python Environment

Create a directory for your agent project and a virtual environment:

mkdir ~/agentic-demo && cd ~/agentic-demo
python3 -m venv venv
source venv/bin/activate

The virtual environment isolates your dependencies from the rest of the system.

4. Install the Required Python Packages

We need the OpenAI Python SDK so that we can talk to Ollama's OpenAI-compatible endpoint:

pip install --upgrade openai python-dotenv

The `openai` package works with Ollama if we override the `base_url`. The `python-dotenv` package will not be strictly necessary here, but it is useful if you later decide to swap in a hosted model with an API key.

Usage Examples: Building a Minimal Agent

Now we arrive at the core of this article. We will build a tiny but fully functional agent in plain Python. It will use the Llama model's *tool-calling* capability to decide when to use a calculator, invoke a local Python function, and then deliver a final answer.

The Agent Loop

Create a file named `agent.py`:

import json
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # required by the SDK, any string works
)

MODEL = "llama3.1:8b"

# ----------------------------------------------------------------------
# 1. Define the tools available to the agent
# ----------------------------------------------------------------------

def calculator(expression: str) -> float:
    """Evaluate a simple arithmetic expression safely."""
    # Only allow numbers, operators, and whitespace
    allowed = set("0123456789+-*/(). ")
    if not all(c in allowed for c in expression):
        raise ValueError("Disallowed characters in expression")
    return eval(expression, {"__builtins__": {}}, {})  # noqa: S307 - sanitized above

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "Evaluate a numeric arithmetic expression.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "The expression to evaluate, e.g. '3 * (2 + 5)'",
                    }
                },
                "required": ["expression"],
            },
        },
    }
]

# ----------------------------------------------------------------------
# 2. Agent main loop
# ----------------------------------------------------------------------

def run_agent(user_prompt: str, max_iterations: int = 5) -> None:
    messages = [{"role": "user", "content": user_prompt}]

    for step in range(max_iterations):
        print(f"\n--- Step {step + 1} ---")

        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=TOOLS,
        )

        message = response.choices[0].message

        # The model may ask us to invoke a tool
        if message.tool_calls:
            messages.append(message)

            for tool_call in message.tool_calls:
                fn_name = tool_call.function.name
                args = json.loads(tool_call.function.arguments)
                print(f"  [Agent] calling {fn_name}({args})")

                if fn_name == "calculator":
                    result = calculator(args["expression"])
                else:
                    result = "Unknown tool"

                # Send the tool result back to the model
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": str(result),
                })
                print(f"  [Tool]  returned {result}")
            continue  # loop again so the model can produce a final answer

        # No tool calls -> final answer
        print(f"  [Answer] {message.content}")
        break
    else:
        print("Max iterations reached without a final answer.")


if __name__ == "__main__":
    prompt = (
        "What is the result of (1234 * 4321) - (99 / 3)? "
        "Use the calculator tool, then give me the final number."
    )
    run_agent(prompt)

Running the Agent

Activate your environment and execute the script:

source venv/bin/activate
python agent.py

What should happen is exactly the agentic loop described at the beginning of this article:

1. The model receives the arithmetic prompt. 2. It reasons that it cannot compute the product reliably and calls the `calculator` tool with an expression. 3. The tool returns the number. 4. The model receives that number and emits a final, verified answer.

The printed transcript will look something like:

--- Step 1 ---
  [Agent] calling calculator({'expression': '(1234 * 4321) - (99 / 3)'})
  [Tool]  returned 5332759.0
--- Step 2 ---
  [Answer] The result of (1234 × 4321) - (99 ÷ 3) is 5,332,759.

Extending the Agent

The pattern scales. To give your agent more capabilities, you simply add more functions to the `TOOLS` list and more branches inside the tool-calling block. For example, you can add a `web_search` tool that hits a search API, a `read_file` tool, or a `run_python` tool that executes arbitrary sandboxed code.

A more production-grade approach is to use a framework like LangGraph, CrewAI, or the OpenAI Agents SDK, which handle conversation state, parallel tool calls, and human-in-the-loop checkpoints for you. But the minimal loop above is ideal for understanding what those frameworks do under the hood. Once you see this ten-step loop, agent frameworks stop being magic.

The Landscape: From Copilots to Coworkers

The shift from generative to agentic AI is not just an engineering exercise; it is a change in how companies think about automation. During the generative era, products like chatbots and copilots required a human to remain in the loop for every meaningful step. The latest announcements from OpenAI, Anthropic, and Microsoft all emphasize agents that operate over longer time horizons and with greater independence. Microsoft's AI blog, for instance, consistently frames AI as a "work assistant" that acts on your behalf, while Anthropic's news and safety pages devote significant space to "computer use" and responsible agentic tool interaction. NVIDIA, for its part, views agents as the next workload driving both model efficiency and data center demand, with its developer blog tracking the full stack of frameworks, GPUs, and inference software that makes multi-agent systems practical.

This convergence is a strong signal: the industry believes the next phase of AI value will come not from generated artifacts but from *accomplished outcomes*.

It is also worth being clear-eyed about the open challenges. Agentic systems are more complex to evaluate. A single chat completion can be judged by its coherence; an agent must be judged on task completion rate, cost per successful task, and safety. They also introduce new failure modes: a tool call can fail, a plan can go off the rails, or a model can hallucinate a function that does not exist. Production system design therefore leans heavily on guardrails: allowed tool allowlists, read-only modes, token budgets, and human-approval checkpoints for high-impact actions. As Anthropic's writings on AI safety argue, the more autonomy we grant models, the more rigorous our alignment and evaluation work must become.

If you are starting to move from generative to agentic AI, here is the pragmatic path I recommend:

1. **Master the minimal loop.** Do exactly what we did above: one model, one tool, a clear goal. 2. **Add tools incrementally** — web search, vector memory, code execution — and observe where the model succeeds and fails. 3. **Add observability.** Log every prompt, tool call, and result. Agentic systems are debugging-heavy, and you will thank yourself for good tracing. 4. **Then move to frameworks** once you understand the loop. You will be able to read their documentation with genuine comprehension, rather than treating their abstractions as black boxes.

Conclusion

Generative AI gave us models that can compose words, images, and code. Agentic AI takes that raw capability and wraps it in a loop of planning, tool use, memory, and reflection — turning a model into an actor in a world of APIs and files. The result is a shift from "ask me anything" to "get it done."

The technological infrastructure for this transition is now accessible to any developer with a laptop. With Ollama, a local open-weight model, and about forty lines of Python, you can build an agent that reasons, calls tools, verifies results, and completes a task end-to-end. The ecosystem leaders — NVIDIA, OpenAI, Microsoft, and Anthropic — are all building on the same fundamental premise: that reasoning models combined with action loops will define the next decade of applied artificial intelligence. The question is no longer *whether* AI will act; it is *how well* we can teach it to act safely, reliably, and in service of genuine human goals.