You've used ChatGPT. Now what?

Want to start with something concrete instead? Lab 00 walks through the first model call without assuming much background.

Start with the familiar version. You open ChatGPT, type a message, hit enter, wait a second, and get a reply. From the outside, that feels like talking to one thing. Under the hood, it helps to split that into two parts.

ChatGPT is the product wrapper. It gives you the website, the conversation history, the buttons, the account, and the little bits of product design that make it feel usable. The model is the program underneath that reads your words and generates the next words back.

A model is a program. Everything else is plumbing. Roughly, it works like a pachinko board: your words go in, something cascades through a giant trained system, and new words come out. That is oversimplified, but it is the right first mental model.

Once a developer wants to build with that model, the product wrapper mostly disappears. Instead of opening ChatGPT in a browser, they call the model directly through an API: a standardized way to send text in and get text back.

{
  "model": "gpt-4o",
  "messages": [
    { "role": "user", "content": "What's the capital of France?" }
  ]
}

That request shape became the default because OpenAI established it early, and most model providers now offer something compatible or close enough to compatible. That is why switching models is often one line of code instead of a full rewrite.

The API is the first layer of plumbing. It is the first point where the raw model becomes something developers can reliably build on.

A model by itself only generates text. That can be useful, but it is limited. If you want it to do something grounded in the world, like search the web, read a file, run code, or check the weather, you have to give it tools.

In plain English, a tool is just something the model is allowed to ask the computer to run. Technically, it is usually a function with a name, a description, and a schema for its inputs. A simple example might be a tool called get_weather with a description like returns current weather for a city.

The model reads that description, decides the tool would help, asks to call it, your code runs it, and the result goes back into the conversation. Then the model keeps going with better information than it had a moment ago. Tools are how a model gets context and takes action.

Once a model can call tools, the next move is simple: do not stop after one step. Let it act, look at the result, decide what to do next, act again, and keep going until it decides the task is done.

That observe → decide → act → evaluate pattern is what people usually mean by an agent. Not always, and the word gets stretched a lot, but this is the clean version worth learning first.

An agent is just a model running in a loop with tools. It is not magic. It is not a separate species of software. It is the same model idea, plus tools, plus control flow.

Once you have the basic thread — ChatGPT product, then API, then tools, then agent loop — the rest of the ecosystem gets less mysterious. Most of the extra terms are just ways to standardize, extend, or control that same pattern.

Tools like Cursor, Claude Code, and Goose are good examples of the whole thing packaged together: a model, tools it can call, and an agent loop, wrapped into something that feels like one product. The pieces underneath those products are what the rest of this site unpacks.

If you want the more precise vocabulary after this page, go next to Models, Protocols, Extensions, or Agents.