0.0. Course

Why an agent calls a tool before it answers

Ask an agent something only your own systems know, and its first output is not an answer but a tool call. It is a typed request naming a function and its arguments, which the runtime executes and feeds back as data before the model writes prose.

The call exists because a model’s knowledge stops when its training does: anything it says about a ticket filed last week was either read from a tool result or invented, and the reply reads the same either way. ADK, Google’s Agent Development Kit and the framework this course builds on, records each call as a functionCall event you can read back after the run, so you can check an answer instead of trusting it.

This page shows that call, the command that checks your model setup, the five paths through the course and what each costs, and the conventions the later pages assume.

In the reference agent, the incidents live in a SQLite file in this repository that no model can have read during training. Asked to list the three open ones, it has nothing to recall and asks instead:

{ "functionCall": { "id": "nYN89WctgaMWcSCnlPw7LG5CxZRRfnTL", "args": { "status": "open" }, "name": "list_incidents" } }

Rows come back from disk, and only then does the model write prose. Question, tool call, tool result, answer: that chain is why every chapter after this one exists — once an agent can touch real things, somebody has to decide what it may touch, prove it behaves, and watch it when it does not.

That turn ran on a laptop, against a model file on that laptop’s disk. A doctor task probes one tier of prerequisites and reports what it found, installing nothing and starting nothing. The model tier gets its own probe because Ollama and the multi-gigabyte Qwen3 download are prerequisites you put in place yourself in 1.4. Providers; the task only says whether they are where the agent expects them, and how fast they answer:

mise run doctor:model

[doctor:model] $ ./scripts/doctor.sh model
model      ready
env        optional .env is absent
ollama     0.32.9 with qwen3:4b-instruct ready on 127.0.0.1:11434
inference  ok in 24s (a full turn needs several calls of this size or larger)

Those four lines are also the entire model bill for the required path: a four-billion-parameter open-weight model answering from local disk, with no account, no API key, and no per-token fee. The last line is the other half of that price. Twenty-four seconds bought one short answer on this CPU-only laptop, and a single agent turn spends several calls at least that size — which is why 1.4. Providers has you measure your own machine before choosing a deadline instead of accepting the default.

What the reference agent already does, and what you add

You start from a finished reference agent: an on-call assistant that reads incidents, logs, and runbooks out of local seed data. It proposes remediation a human must approve, and you take it through the operational lifecycle. First you give it capabilities: typed tools, Agent Skills, MCP, retrieval, workflows, and agent-to-agent calls. Then you make it accountable, with tests, behavioral evaluations, PII redaction, human approval, and an append-only audit trail. Then you put agentgateway in front of its traffic, ship it as one container image onto a local k3d cluster with kagent, and wire OpenTelemetry into self-hosted Tempo, Loki, Prometheus, and Grafana so you can watch a single turn end to end.

Every action and dataset stays local and fictional, which makes the boundaries real without making the consequences real. main is the finished reference; the capstone asks you to keep its platform contracts while replacing the example domain with your own. You need Git, a terminal, and basic Go.

What six adjacent courses do better

Several other courses beat this one at something that matters. Here is where each is stronger, read on 11 August 2026:

Each went deeper on one slice than any lifecycle course can. None walks one application the whole way: build it, prove it, govern its traffic, ship it, and watch it run. That loop, with no SaaS, no cloud account, and no fee on the required path, is what this course claims — and “the only” is the result of a search on 11 August 2026, not a proof. Syllabi move monthly; the quarterly freshness audit re-reads every row, and 8.5. Contributions is where you correct one. If your team prototypes in Python, this course taught the same lifecycle in Python through v0.7.0 and that version is archived on the python branch; 8.8. From Python maps the concepts across.

Pick one of the five paths through the course

A path is the set of prerequisites you commit to: which model you run, and whether you need a cloud account. Together they decide what the course can cost you.

The required path costs no money and no signup; it spends your compute, storage, and electricity, and a slow CPU turn is the most common first-day friction. Gemini and Google Cloud usage can be billed, and 7.3. Costs owns the dated estimate you refresh before approving anything. Every required piece is open source, down to the Apache-2.0 Qwen3 weights and the Go evaluation harness; Gemini, Vertex AI, GKE, and GitHub hosting are proprietary services the course names as optional and never relabels.

How to work through each page, and in what order

Four conventions hold everywhere. Run commands from the repository root unless a block says otherwise. Every critical Go excerpt is read out of its source file when the site builds, so a moved region fails the build rather than serving you stale code. Clear a page’s checkpoint — the command whose output decides whether you may go on — before enabling the next tier of prerequisites, whose failures are far easier to read alone.

And every Your turn block declares a Mode before its first step, because the mode is what the exercise costs your working tree: inspect runs read-only commands and changes nothing, temporary experiment edits named files and ends with the command that restores them, and keep leaves the change in place on purpose. Skip any exercise freely: no page’s prerequisites name something an earlier exercise produced, so a skipped keep costs you nothing later.

In a hurry? A little over three focused hours gets you the shape of the whole thing, setup included, because each page below needs only what the pages before it left behind, with the single exception named at the end: 1.0. System installs, 1.4. Providers pulls the model, 2.1. First Agent runs a grounded turn, 3.1. Tools adds a typed read, 4.4. Evaluations writes an adversarial case, and 1.2. Container Engine then 6.1. Containers get your image running. The exception is the checkpoint on 1.2: mise run doctor:gateway also requires yq, which arrives with mise run install:platform rather than with the mise run install of 1.0, so run that one extra task before it. Skip a page and the next stalls.

What you can do now

• You can say what an agent does with a question it cannot answer, and why that move is the thing worth operating.
• You know which of the five paths you are taking, and that the default needs no account and no fee, only your own compute and patience for a slow first turn.
• You know that 1.0. System begins the installation, and nothing before it needs anything installed.

Two decisions are yours: whether an agent is worth operating at all, and which path you take through this one. Either answer may be “not this, not yet”.

Continue to 0.1. Agents, which turns that one tool call into a working definition of an agent and the loop it runs.