Building your first AI agent

Part 1 · Theory (30 min)

Anatomy of an AI agent

A chatbot answers in one shot. An agent works toward a goal: it plans, uses tools, remembers what it found, and acts — over and over — until the job is done. Four parts make that possible.

The ReAct loop: Reason + Act

The most common recipe for agents is called ReAct. It's a simple loop the model repeats: think about what to do, do it, look at the result, and go again.

# repeat until the goal is reached:
Thought   → "I need the latest AI-education headlines."
Action   → search_web("AI in education 2026")
Observation → [3 articles come back]
Thought   → "Now summarize them into 3 bullets."
Action   → summarize_text(articles)
Observation → [a clean 3-bullet summary]
Thought   → "Goal reached. Give the final answer."

The Kaggle ecosystem

Kaggle is where the data-science world learns, competes, and shows off. Three parts matter to you right now:

• Competitions — real problems with datasets and a leaderboard. "Getting Started" ones (like Titanic) are made for beginners.
• Datasets — thousands of free, ready-to-use datasets you can load in one line.
• Notebooks — Colab-style notebooks you can publish so anyone can see your work.

Part 2 · Practical (90 min)

Build the "DataFetcher" agent

Now you build the loop for real in Colab. The DataFetcher is an agent that, given a goal, calls tools to fetch and summarize live information. Here's the shape — the full, runnable version is in the Week 2 notebook.

Step 1 — Set up & initialize the LLM

Install the SDK and connect to Gemini (free via Google AI Studio). You'll also import pandas and requests for later.

# in Colab
!pip install google-genai pandas requests
from google import genai
client = genai.Client(api_key=API_KEY)   # key from aistudio.google.com/apikey

Step 2 — Create the tools

A "tool" is just a Python function the agent can choose to call. We give it two. For reliability in class, search_web() returns mock news (a real NewsAPI key is optional).

def search_web(query: str) -> str:
    """Return recent headlines for a topic."""
    return MOCK_NEWS   # swap in a real API later

def summarize_text(text: str) -> str:
    """Ask the LLM to shrink text to 3 bullets."""
    return client.models.generate_content(
        model=MODEL,
        contents=f"Summarize in exactly 3 bullets:\n{text}",
    ).text

Step 3 — The agent loop

Hand the tools to the model and let it drive: it decides which tool to call, you run it, feed the result back, and repeat until it has a final answer. That while loop is the agent.

while True:
    reply = model_step(history, tools=[search_web, summarize_text])
    if reply.wants_tool:                 # Thought → Action
        result = run_tool(reply.tool, reply.args)
        history.append(result)          # Observation → Memory
    else:
        print(reply.text); break          # goal reached

Kaggle data integration — meet the Titanic

Finally, point the agent at structured data. You'll load the famous Titanic dataset in one line and ask a simple question — a preview of Week 3's data-analysis agents.

import pandas as pd
df = pd.read_csv("https://.../titanic.csv")   # one line to load
# agent task: "What's the average age by gender?"
df.groupby("Sex")["Age"].mean()

⚡ Energizer · The Human ReAct Loop

Before the build, get everyone on their feet for 12–15 minutes and run the agent loop as humans — it makes the code obvious afterward.

Homework & deliverables

• Explore one "Getting Started" Kaggle competition (Titanic is perfect) — just click around and read a top notebook.
• Brainstorm an initial project idea and jot it in the shared project template — you'll scope it properly in Week 3.

Recap. An agent = Planning → Tools → Memory → Action, run as the ReAct loop (Reason + Act). You built a DataFetcher that calls tools to fetch and summarize live info, met Kaggle (your portfolio home), and loaded your first real dataset. Next week: agents that reason over that data — and you'll scope your own project.