Why this matters: build to learn in an AI transition

The opening question

Frank Coyle opens by introducing himself as a Berkeley educator with a long background in computer science. He frames the talk around a change in what students and practitioners can expect from the field.

His framing is this: there was an earlier expectation that earning a computer-science degree would reliably lead to a job. He says that artificial intelligence has changed that situation. He presents agents as one promising direction within this changing landscape, then asks a practical question:

How can we make use of the rapidly changing capabilities of AI?

This is the motivation for the rest of the lesson. The talk will eventually argue that agents should work together with ontologies. At this point, however, the connection is still an open question. The opening names both ideas before explaining why they belong together.

What “agent” means here

In this lesson, an agent is not simply a system that writes a reply. It is a system that can participate in a continuing process of interpreting a situation, deciding what to do, and taking an action. Later chapters examine that process in detail.

For now, the important point is that agents make AI more active. They may need to choose steps, use tools, inspect results, and continue. That creates a larger design problem than generating one piece of text: we must understand and check what the system is doing.

Learn by making

Before presenting the technical material, Coyle gives a learning principle. He attributes the following idea to Sister Corita Kent and says it was popularized by John Cage:

Nothing is a mistake. There is no win or fail. There is only making.

The phrase does not mean that all system behavior is correct. It describes a way to approach learning. Instead of waiting until we know enough to produce a perfect result, we make something, observe it, and use what we observe to improve our understanding.

For this talk, “making” can include several activities:

1. Build something. Create a small agent or representation rather than only reading about one.
2. Inspect what happens. Look at the agent's steps, tool calls, and results.
3. Write notes. Record the concepts and relationships that are easy to lose in a fast-moving technical discussion.
4. Draw the system. Make entities, relationships, loops, and checks visible.

This approach is especially useful for agentic systems. An agent loop can look simple when described in a sentence, but its behavior becomes clearer when we draw the path from a request to a decision, then to a tool call, a result, and a possible next step.

Why writing and drawing can help

Coyle also recommends writing in a book rather than relying only on typing. His stated rationale is that typing directs attention mainly toward the letters on the keyboard. Writing by hand can involve a broader sensory experience: the page, the movement of the hand, and the physical act of making marks.

This is the speaker's learning rationale, not a general scientific law established by this chapter. The practical lesson is simple: use a method that makes you attend to the structure of the idea.

For example, while learning this talk, you could draw four boxes:

request → agent decision → tool call → checked result

Then add labels for the questions you want to answer:

• What does the agent know about the domain?
• What is it allowed to do?
• How can the system tell whether a tool result makes sense?
• What happens when the result is not reasonable?

The drawing is not yet an ontology or a complete agent design. It is a learning aid. It turns an abstract process into something that can be inspected and revised.

The technical question that follows

The opening connects two needs:

• AI agents provide flexible generation and action planning.
• A dependable system also needs a way to represent what things mean in its domain and to check whether proposed actions fit that domain.

An ontology is the formal domain model that the later chapters develop. It can make important entities, relationships, and properties explicit. A validator or reasoner can then use that model to examine information produced during the agent's work.

The exact division of labor is not explained yet. The later argument will address it. The key setup is that an agent's flexibility may need a structured reference point. Without such a reference point, it is harder to inspect whether the agent's proposal fits the world it is supposed to operate in.

A useful mental model

Think of the opening as proposing a two-part learning and engineering habit:

1. Make the system concrete. Build, run, write, and draw.
2. Make the system inspectable. Represent its important concepts and check its behavior.

The first part helps the learner understand a changing technology through direct experience. The second part points toward the talk's central engineering proposal: combine the flexible behavior of an AI agent with explicit domain structure and checks.

Chapter takeaway

Coyle's opening is both a motivation and a method. He presents agents as a response to a changing AI landscape, but he does not treat rapid change as a reason to stop and wait for certainty. He encourages learners to build things, observe them, and use unexpected results as material for learning.

That attitude leads naturally to the unresolved question for the next part of the talk:

If an agent can perceive, decide, and act, what structured understanding of its domain should guide and check those actions?

The following chapter begins answering that question by tracing the separate lineages of agents and ontologies.