Powering the agent

Three upgrades → build

A function the model can call

• A tool is just a function you write — code the agent is allowed to run.
• The model decides WHEN to call it; your code decides WHAT it does.
• The LLM never runs your code itself — it asks, you run it, you hand back the result.

Name it, describe it, guard it

def get_weather(city: str) -> dict:
    """Get today's weather for a city.
    Args: city — full city name, e.g. "Austin".
    Returns: {temp_f, summary}. Raises if city unknown."""
    if not city:
        raise ValueError("city is required")   # guard the input
    return weather_api.lookup(city)

Tools agents actually use

The agent's job description

• Who it is — its role and tone ("You are a helpful research assistant").
• What tools it has — and when to reach for each one.
• Its rules — what to always do, what to never do, how to handle 'I don't know'.

Vague in → vague out

Short-term vs. long-term

Declare a tool, recall a memory

# 1 — give the agent a role AND a tool
config = types.GenerateContentConfig(
    system_instruction="You are a study buddy. "
        "Use remember() to look things up before answering.",
    tools=[remember],                 # function calling
)

# 2 — long-term memory: search, don't dump
def remember(query: str) -> str:
    hits = memory_db.search(query, top_k=3)
    return "\n".join(hits)      # only the 3 most relevant notes

resp = client.models.generate_content(
    model="gemini-2.5-flash", config=config, contents=history)

Your agent leveled up 🎉

• Tools = functions the model calls — it decides when, your code decides what.
• The system prompt is the job description; be specific, show examples, iterate.
• Memory: short-term (context window) vs long-term (searchable vector DB).

Next session → Agents in the real world: architectures, building your own, and keeping them safe.