AI Foundations: From Automation to Agents

What is AI — and what is not?

Artificial intelligence is the broad field of building computer systems that perform tasks associated with human intelligence, such as recognizing patterns, understanding language, making predictions, and selecting actions. Machine learning learns patterns from data. Generative AI creates new content from those patterns. Agentic AI adds goals, decisions, tools, and repeated action.

Not every automated system is AI, and not every AI system is an agent. A fixed rule that sends a scheduled email is automation. A model that predicts whether an email is spam uses AI. A system that reads a request, plans several steps, calls tools, checks results, and adjusts its approach behaves like an agent.

From tools to agents — what changed?

You may already have typed a question into a generative AI assistant and received an answer. That is useful, but answering once is different from pursuing a goal through multiple actions.

Here's the difference. A tool does one thing when you ask it to. A calculator computes. A search engine retrieves. A basic chatbot answers. You push, it responds, done.

An AI agent is different. Give it a goal, not a command — and it takes a sequence of actions to achieve it. It plans, acts, observes what happened, adjusts, and tries again. It doesn't stop after one response. It keeps going until the job is done — or until it decides it can't do it.

The shift from "AI that answers questions" to "AI that completes tasks" is the shift from model-assisted tools toward agents. Understanding that distinction is the foundation for everything that follows.

The reasoning loop: Think → Act → Observe

Every AI agent — from the simplest research bot to the most complex enterprise pipeline — runs on the same fundamental loop. Understanding this loop is the foundation of everything in this course.

Let's trace through a real example. Say you tell a research agent: "Find me everything published about KEDA autoscaling in 2025."

THINK: "I need to search for academic papers and blog posts about KEDA autoscaling from 2025. I'll start with a web search."
ACT: Calls the web search tool with the query "KEDA autoscaling 2025"
OBSERVE: Gets 10 results back. Three are relevant, seven are not.
THINK: "I have 3 good sources. I should read each one fully and also try a more specific search."
ACT: Opens the 3 URLs. Calls search again with a refined query.
OBSERVE: Now has 5 good sources with full content.
THINK: "I have enough. I'll synthesize this into a summary."
ACT: Writes the summary.
OBSERVE: Done. Goal reached.

That whole sequence happened without you directing each step. You gave it a goal. It figured out how to get there.

AI agents you already use

Agents aren't science fiction. You interact with them constantly — most people just don't recognize them as agents. Here are three you know, mapped to the loop:

What the notebook covers

Here's a sneak peek at what you'll run in the notebook. This is real Python — a simple simulation of the agent reasoning loop. No AI API needed.

# Week 1: AgenticEd — Simulating the Think → Act → Observe loop

def simple_agent(goal, tools, max_steps=5):
    """A minimal agent loop in Python."""
    memory = []
    step = 0

    while step < max_steps:
        # THINK: Decide what to do next
        thought = think(goal, memory)
        print(f"💭 THINK: {thought}")

        # ACT: Use a tool
        action, result = act(thought, tools)
        print(f"⚡  ACT: {action}")

        # OBSERVE: See what happened
        observation = observe(result)
        memory.append(observation)
        print(f"👁  OBSERVE: {observation}\n")

        if goal_reached(result):
            break
        step += 1

    return memory

# Run it:
simple_agent(goal="Find 3 facts about AI agents", tools=["search", "summarize"])

The notebook walks you through building this from scratch, step by step. Each cell explains what's happening and why.