What is AI, really?
Strip away the sci-fi. An AI model is a pattern-matching engine trained on staggering amounts of human text and images. Give it a prompt; it predicts the most likely next token — over and over — until it has written you an answer.
That's the whole trick. The magic is scale: trillions of patterns, remembered and recombined faster than thought. It doesn't "know" things the way you do — it models them so well it looks like knowing.
The word LLM — large language model — just means "a big pattern engine that works in words." When people say "AI" today, 99% of the time they mean an LLM.
CHECKPOINT 01
At its core, an LLM generates text by:
Chatbot vs Agent — the line that matters
This is the single most useful distinction you'll learn. Get it and everything else clicks.
A chatbot answers. You ask; it replies. It lives in the conversation and touches nothing outside it. Great for "write me a poem" or "explain inflation."
An agent acts. You give it a goal; it decides what to do, uses tools (search the web, run code, read a file, send a message), checks the result, and loops until the job is done. It can operate for minutes across many steps without you babysitting it.
The D.O.A.I. crew are agents. FLUX PRIME scans the markets; ORBIT builds the thesis; ATLAS keeps the ledger; SENTINEL watches for risk. None of them just "chat" — they run.
One-line test
If it can open a browser, run code, or move a file to finish your request — it's an agent. If it can only type back at you — it's a chatbot.
CHECKPOINT 02
Which is an AGENT, not just a chatbot?
Anatomy of an agent
Every agent — from a toy demo to the D.O.A.I. crew — is built from the same four parts. Learn these and you can read any AI system like a schematic.
① The Model (the brain)
The LLM that reasons. It reads the situation and decides the next move. It does the "thinking."
② The Tools (the hands)
Things the model can do: web search, code execution, file read/write, API calls, sending messages. Without tools, a model is trapped in its own head.
③ The Memory (the log)
What it remembers between steps — and between sessions. Short-term memory is the running conversation; long-term memory is saved notes, files, or a vector store.
④ The Loop (the heartbeat)
The engine that repeats: Perceive → Think → Act → Observe. One turn isn't enough; the loop is what turns a one-shot reply into a finished job.
Below is the same anatomy as a live graph. The center is the agent core; the orbiting nodes are its parts. This is also the engine behind the simulator in the next chapter.
CHECKPOINT 03
Which part lets an agent actually DO things in the world?
Watch one work — the agent loop, live
This is a sandbox simulation — it runs entirely in your browser, makes no network calls, and uses no API keys. Type a goal and watch a simulated agent think through the Perceive → Think → Act → Observe cycle. It's scripted to feel real, so you learn the shape of agency.
CHECKPOINT 04
After an agent Acts (e.g. runs a search), what should happen next?
Prompting — your control surface
You don't program an agent in code (usually). You program it in words. That's prompting. Treat the model like a brilliant, literal, amnesiac junior operator: tell it the role, the context, the constraints, and the format.
Four moves that work
1. Assign a role: "You are a careful financial analyst…"
2. Give context: paste the data, the link, the situation.
3. Set constraints: "under 100 words," "no hype," "cite sources."
4. Demand a format: "return a table with columns X, Y, Z."
Weak prompt: "tell me about stocks". Strong prompt: "You are a portfolio analyst. From the tickers [NVDA, PLTR], summarize the last quarter in 3 bullets, flag any risk, and cite the source for each claim." Same model, wildly different output.
CHECKPOINT 05
Which prompt is most likely to give a useful, controlled answer?
Guardrails, cost & staying in control
Agents are powerful and predictably unpredictable. Three things to respect from day one.
① They can be confidently wrong
Models hallucinate — they fabricate facts that sound true. Always verify anything that matters. This is why we cite sources on this very page.
② They cost money & time
Every token costs compute. A loop that runs 40 steps costs ~40× a single reply. Set limits (max steps, max spend) so an agent can't run wild.
③ They need permissions
An agent with "send email" access can send email. Gate dangerous tools behind approval. The D.O.A.I. crew runs on a hard rule: no auto-apply without an operator's ✅.
Rule of thumb: start read-only. Add one write-tool at a time. Watch it. Only then trust it with more.
CHECKPOINT 06
A model states a fact with total confidence, but you can't verify it. Best move?
Your first agent & where to go next
You've got the map. Here's a safe first mission you can run today, no install required:
Starter mission
Open a free chatbot. Give it this prompt:
"You are my research agent. Find 3 reputable sources on [your topic]. For each, write one sentence on what it says and one on why it matters. Stop and ask me before doing anything else."
You just ran an agent-shaped task: role + goal + constraint + a safe stop.
From there, the rabbit hole is deep and free. Pick a thread:
CHECKPOINT 07
Best first step to learn agents safely?
The AI Field Guide: From Chatbot to Agent
A trail map through the AI landscape — plain-language stops from "what is a chatbot" all the way to agent loops, harnesses, and multi-agent orchestration. Climb at your own pace. Every stop has a plain-English definition, a real-world analogy, and no jargon left unexplained.
Orientation: The Three Nested Words
Before the trail starts, get your bearings on the words people use interchangeably (and shouldn't).
Think of it as three nested circles. The outermost is the field. The innermost is the specific technique behind today's chatbots.
The whole field — any technique that makes a machine do something that looks like intelligent behavior. Includes everything below, plus things like chess engines and spam filters.
A subset of AI where the machine learns patterns from data instead of being hand-coded with rules. It gets better by example, not by instruction.
A subset of ML that uses layered neural networks (many stacked layers of simple math units) to learn very complex patterns — this is what powers modern language and image models.
Every large language model is deep learning, which is machine learning, which is AI. But not all AI is a language model — a thermostat that adjusts itself isn't "thinking," it's just AI in the loosest sense.
Chatbots & the Language Model Underneath
A chatbot is the costume. A large language model (LLM) is what's wearing it.
A chatbot is just a chat-shaped interface. The intelligence behind it is usually a large language model — a system trained to predict the next chunk of text, over and over, until a full answer forms.
A model trained on huge amounts of text to predict what word (or word-fragment) comes next. Scale it up enough and "predicting the next word" starts to look like reasoning.
The model's unit of text — roughly a word or word-piece. Unbelievable might be 3 tokens: un believ able. Models read, think, and get billed in tokens.
How much text (in tokens) the model can "see" at once — the current conversation, documents, instructions. Once you exceed it, the oldest content falls off the back.
The text you feed the model to get a response. Prompt engineering is the craft of writing that input so the model does what you actually want.
The internal numeric "knobs" the model learned during training — often billions of them. Roughly (very roughly) correlated with capability; "a 70-billion parameter model" is a size descriptor.
Training is the (expensive, one-time-ish) process of teaching the model from data. Inference is every time you actually run it to get an answer — that's what happens when you chat with it.
"Chatbot" describes the job (conversation). "LLM" describes the engine doing the job. You can put an LLM behind a voice assistant, a code editor, or an autonomous agent — the chatbot is just the most familiar costume.
How the Model "Thinks"
Under the hood, it's pattern-matching at staggering scale — not a brain, but not "just autocomplete" either.
A web of simple math units ("neurons") arranged in layers. Loosely inspired by the brain, but really just matrix multiplication stacked many times over.
The neural network architecture behind nearly every modern LLM. Its key trick is attention — letting the model weigh which earlier words matter most for predicting the next one.
Turning a word, sentence, or image into a list of numbers (a vector) that captures its meaning — so "king" and "queen" end up mathematically close together.
A setting that controls randomness. Low temperature = safe, predictable, repetitive answers. High temperature = more creative, more unpredictable, more likely to go off the rails.
When a model confidently states something false. It's not lying on purpose — it's pattern-completing without a built-in fact-checker, and the output just happens to be wrong.
Hidden instructions set before the conversation starts, defining the model's role, tone, and rules — the "job description" the user doesn't usually see.
Taking an already-trained model and training it further on a narrower dataset so it specializes — e.g., a general model fine-tuned to write legal contracts.
Reinforcement Learning from Human Feedback — humans rank model answers as better or worse, and the model is nudged toward the preferred style. This is a big part of why modern chatbots feel polite and helpful.
Giving the Model Hands: Tools & Retrieval
A raw LLM can only talk. Give it tools and fresh data, and it can start to do things.
On its own, an LLM only knows what was in its training data, frozen at a point in time. Tool use and retrieval are how it reaches outside itself.
The model is given a menu of actions it can request — search the web, run code, query a database — and it outputs a structured request to use one, instead of just text.
Before answering, the system fetches relevant documents (your files, a knowledge base) and stuffs them into the prompt — so the model answers using real, current material instead of guessing from memory.
A database built to store embeddings and quickly find "things that mean something similar" — the engine that usually powers RAG's search step.
The standard doorway software uses to talk to other software. When an app "calls the model," it's sending a request through the model's API.
Tool use is the hinge point of this whole guide. Before it: a chatbot that talks. After it: something that can look things up, take actions, and start chaining those actions together — which is where "agent" begins.
Agents: From Answering to Acting
An agent isn't a bigger model — it's a model wrapped in a loop that lets it act, check its work, and try again.
A chatbot answers once and stops. An agent keeps going: it takes an action, looks at the result, decides what to do next, and repeats until the goal is done (or it gives up).
The repeating cycle above — the defining mechanic of every agent. It runs until a stopping condition is met: the task is done, a limit is hit, or a human steps in.
Letting the model "think out loud" in intermediate steps before giving a final answer, which measurably improves accuracy on hard, multi-step problems.
The agent breaking a big goal into smaller sub-steps before acting — "to do X, I'll first need to do A, then B, then C."
What the agent holds in its current context window — this conversation, this task. Gone once the session ends, unless saved somewhere.
Information persisted outside the context window — in a file, database, or vector store — that the agent can retrieve in future sessions. This is how an agent "remembers you" tomorrow.
How much an agent acts without a human approving each step. Low autonomy = asks permission constantly. High autonomy = runs many steps unsupervised.
Harnesses & Scaffolding
The model is the engine. The harness is everything built around it so the engine doesn't drive off a cliff.
The surrounding software that runs the agent loop, feeds the model its tools and context, catches its outputs, and enforces limits — the rig the model sits inside. "Claude Code" and similar tools are harnesses around an LLM.
Closely related to a harness — the structural code and prompting patterns that shape how the model approaches a task, often built to be stripped away or swapped out later.
Rules and filters that constrain what the agent is allowed to do or say — blocking certain actions, validating outputs, catching unsafe requests before they execute.
Running the agent's actions (especially code execution) in an isolated environment, so if something goes wrong, it can't touch the real system or real data.
Short for evaluations — standardized tests used to measure how well a model or agent performs on a task, so changes can be compared objectively instead of by vibes.
A checkpoint where a person must review or approve before the agent proceeds — a deliberate brake on autonomy at a risky step.
If the model is a driver, the harness is the car: steering limits, seatbelts, a dashboard, a speed governor. Same driver, wildly different outcomes depending on the vehicle wrapped around them.
Orchestration: When Agents Team Up
One agent can only hold one train of thought. For complex work, you split the job across several.
Several agents, often with different roles or specialties, working on pieces of the same overall problem instead of one agent doing everything.
A "manager" agent (or system) that breaks a goal into sub-tasks and delegates them to other agents or sub-agents, then assembles their results.
The overall practice of coordinating multiple agents, tools, or steps so they run in the right order, share the right information, and don't collide.
A fixed sequence of steps data flows through — step 2 always runs after step 1. More rigid than an agent, more predictable too.
A workflow follows a predetermined path (if this, then that). An agent decides its own path as it goes. Most real systems are a blend of both.
The moment one agent passes a task (and its context) to another agent better suited to continue it.
Ops & Infrastructure: Keeping It Running
The unglamorous plumbing that makes AI systems reliable, scheduled, and connected.
A task scheduled to run automatically at set times (e.g., "every day at 6am") — named after the old Unix cron scheduler. This is how an agent runs on a routine without a human clicking "go."
A way for one system to instantly notify another when something happens — "when a new email arrives, ping this URL" — instead of constantly asking "anything new yet?"
An open standard for connecting AI models to external tools and data sources in a consistent way — so a new tool can be plugged in without custom one-off code for every model.
A secret credential that identifies and authorizes a request to a service — the "key" that proves your app is allowed to use the model.
A cap on how many requests you can make in a given time window, to keep systems stable and usage fair.
Latency is how long one request takes. Throughput is how many requests the system can handle in total, at once.
The Frontier
Terms you'll hear in the conversation about where this is all headed.
A hypothetical AI that can match human ability across essentially any intellectual task — not yet achieved, and there's real debate over what would even count.
The work of making sure an AI system's goals and behavior actually match what humans intend — a harder problem than it sounds, especially as systems get more autonomous.
The observed pattern that model performance improves fairly predictably as you increase data, compute, and parameters — the reasoning behind "just make it bigger."
A capability that shows up in larger models but wasn't present (or wasn't as strong) in smaller ones — it "emerges" from scale rather than being explicitly trained in.
A model that handles more than just text — images, audio, video — combining them in a single system instead of needing separate tools for each.
Specimen Index
Every term from the trail, alphabetized. Tap to expand. Search to jump straight to one.