What Agentic AI Is: The Third Wave

Artificial Intelligence has moved through three distinct "Waves." To understand where we are today, we must understand the shift from Generative AI (answering questions) to Agentic AI (solving problems).

1. The Three Waves of AI

Wave 1: Discriminative AI (2012-2021): Identifying things. Is this a cat or a dog? Is this email spam?
Wave 2: Generative AI (2022-2023): Creating things. Write a poem, draw a picture, explain code.
Wave 3: Agentic AI (2024-Present): Doing things. Book a flight, research a competitor, fix a bug in a repository.

2. Defining the "Agent"

At its simplest, Agentic AI refers to software powered by a Large Language Model (LLM) that can use tools and make decisions to achieve a high-level goal.

In a traditional program, the developer writes every "if/then" statement. In an agentic system, the developer provides the Goal and the Tools, and the LLM determines the Steps.

3. The Agentic Architecture

Every agentic system consists of a loop. The model observes its environment, thinks about what to do, takes an action, and then observes the result.

graph TD
    Goal[User Goal] --> Loop[Control Loop]
    Loop --> Reason[Reasoning & Planning]
    Reason --> Action[Action/Tool Use]
    Action --> Observe[Observe Result]
    Observe --> Loop
    Loop --> Final[Goal Reached]

4. Why Now?

We have had "agents" (like Siri or Alexa) for years. Why is this different?

Reasoning Capabilities: Models like GPT-4 and Llama 3 can now "think" through multiple steps without losing the thread.
Tool Use (Function Calling): Models are now trained specifically to output structured data (like JSON) that a computer can execute.
Context Windows: Large memory buffers allow agents to "remember" long-running tasks.

5. Code Example: A Conceptual Agent Loop

Even before we use frameworks like LangChain, a "Manual" agent looks like this in Python:

import ollama

def manual_agent(task):
    history = [
        {"role": "system", "content": "You are an agent. Solve the task. If you need a tool, output 'TOOL: tool_name'. If you are done, output 'FINAL: result'."},
        {"role": "user", "content": task}
    ]
    
    # Simple loop for 3 steps
    for i in range(3):
        response = ollama.chat(model='llama3', messages=history)
        content = response['message']['content']
        print(f"Step {i+1} Thought: {content}")
        
        if "FINAL:" in content:
            return content
            
        # Simulate tool execution and observation
        history.append({"role": "assistant", "content": content})
        history.append({"role": "user", "content": "Observation: Tool executed successfully. Here is the data..."})

# Run the agent
manual_agent("Check the stock price of AAPL")

Key Takeaways

Agentic AI is focused on "Doing" rather than just "Talking."
It operates in a Reasoning-Action-Observation loop.
The developer defines the Objective, not the specific Code paths.
The transition to agents is driven by stronger reasoning and native tool use in modern LLMs.

Module 1 Lesson 1: What Agentic AI Is