Glossary

What you meet before any AI at all: how typed words become computer actions.

• TerminalA window you type into to talk to your computer.animatedexampledeep dive
• CLI (Command-Line Interface)Directing a computer by typing instead of clicking.animatedexampledeep dive
• ShellThe program that reads what you typed and goes and runs it.exampledeep dive
• PATH and file pathsA path is a file's address. PATH is the list of folders the computer searches when you name a program.exampledeep dive
• Environment variables and .envConfiguration a program reads from outside itself, instead of values hardcoded in the source.exampledeep dive
• GUI (Graphical User Interface)The point-and-click face of a program: windows, buttons, menus and icons — the counterpart of the type-it-yourself command line.animatedexampledeep dive
• Working directoryThe folder you are currently "standing in": any command that does not name a full path acts here by default.exampledeep dive
• Config fileA file a program reads its own settings from — which model, which port, where keys live — written once, applied on every run.exampledeep dive
• JSON (JavaScript Object Notation)A lightweight data format in plain text that both humans and programs can read — the common language of AI tooling.exampledeep dive
• YAMLThe other common config format: nesting expressed by indentation, closer to a human outline than JSON — and far pickier about whitespace.exampledeep dive
• ProcessA program while it runs: it owns its memory, has its own number (PID), and lives until it exits or is killed.exampledeep dive
• PortA number appended to an address so one machine can run many network services at once without mixing them up.exampledeep dive
• Localhost"This very machine": localhost is the name, 127.0.0.1 the address. A service bound to it can be reached only from this computer.exampledeep dive
• Standard streams (stdio)The three data pipes every process is born with: stdin to read from, stdout for normal output, stderr for errors — three separate channels.animatedexampledeep dive
• Exit codeThe integer a program hands back as it exits: 0 means success, anything else means failure — how a program reports its outcome to the world.exampledeep dive
• File permissionsRules attached to every file saying who may read it, change it and execute it — the first gate the system checks when you touch a file.exampledeep dive
• sudo (superuser do)Run this one command as the administrator (root): the command stays the same, the identity changes.exampledeep dive
• HomebrewThe de-facto package manager on macOS (and Linux): one command to install, update and remove tools and applications.exampledeep dive
• IDE (Integrated Development Environment)A program that bundles code-writing with everything around it in one window: a file tree, syntax highlighting, an integrated terminal, run and debug.exampledeep dive
• DotfileFiles whose names begin with a dot: hidden from listings by default, because they are usually configuration rather than content you browse.exampledeep dive

Names you keep hitting while installing tools and running examples. You do not need to write code, but you do need to recognise these.

• PythonA programming language, and also the program that runs it. Almost every AI tool's docs, examples and error messages are written in it.exampledeep dive
• Node.jsThe program that lets JavaScript run outside a browser — and the thing many AI command-line tools are installed and launched with.exampledeep dive
• Package managerA tool that downloads, installs, updates and removes other people's software for you. Each ecosystem has its own.exampledeep dive
• pipPython's own installer: it fetches packages from the PyPI repository and puts them into whichever Python you are currently using.exampledeep dive
• Virtual environment (venv)A project-private folder of Python packages, kept apart from the system. Once activated, whatever pip installs lands only inside it.exampledeep dive
• DependencyFor your program to work, other people's programs must already be present. Those prerequisites are its dependencies.exampledeep dive
• Repository (repo)A project folder plus a record of every change made to it since day one.exampledeep dive
• Git (version control)A tool that records how a folder changes over time: who changed what, when — and lets you go back at any point.exampledeep dive
• CommitOne save: the project's entire state at one moment, recorded together with a note explaining it.exampledeep dive
• BranchA parallel line of work forked off the main one. However much you change on it, the main line does not move.exampledeep dive
• Clone and forkclone copies a remote repo onto your computer with a command; fork copies someone else's repo into your own account on a website.exampledeep dive
• Pull request (PR)A formal request saying 'I have made these changes — please decide whether to take them in'. It is a human review process, not a command.exampledeep dive
• ScriptA file holding a sequence of commands run in order — the things you would otherwise type in a terminal, saved so they can be run again.exampledeep dive
• FunctionA named, reusable piece of code: you give it inputs and it hands back an output.animatedexampledeep dive
• Library vs frameworkA library is something you call; a framework is something that calls you.exampledeep dive
• API (Application Programming Interface)A published contract: send a request in the specified shape and get a reply in the specified shape, with no need to know how the other side works internally.exampledeep dive
• SDK (Software Development Kit)A service's own pre-packaged toolkit: it wraps the details of calling its API into a few convenient functions so you do not assemble requests yourself.exampledeep dive
• Regex (regular expression)A notation for describing what a piece of text looks like, used to find or validate matching fragments inside larger text.exampledeep dive
• DebuggingReading an error message properly, finding the line that actually failed, and changing only that.exampledeep dive
• RuntimeTwo meanings: the program that executes your code (the Python interpreter, Node.js, a browser); and the period while your code is actually running, as opposed to the moment it was written.exampledeep dive

What happens when you call an API or reach another machine.

• API keyA secret string that tells a remote service "this request is yours, and the bill is yours".exampledeep dive
• SSH (Secure Shell)An encrypted connection into another computer's command line.animatedexampledeep dive
• HTTPThe request/response language between clients and servers — and the transport every model API uses.exampledeep dive
• Request/responseOne round trip: you send a request, the server sends a response, and the connection can close — it does not remember your previous call.exampledeep dive
• Status codeThe three-digit number on the first line of a response, telling you whether the call succeeded, whether you made a mistake, or whether the server did.exampledeep dive
• Header (HTTP header)Notes attached to a request or response about this transfer: identity, content format, caching, where to redirect. The actual data is in the body; headers are the annotations on the envelope.exampledeep dive
• Rate limitThe cap on how many requests or tokens a service lets you send in a given window; go over it and you are throttled with a 429.exampledeep dive
• WebSocketA connection that stays open once established, letting both sides push data at any time — unlike HTTP's ask-once, answer-once, then close.exampledeep dive
• ProxyA middleman between you and the destination: your request goes to it first, it asks on your behalf, then relays the answer back.exampledeep dive
• CORS (Cross-Origin Resource Sharing)A browser security gate: when page JavaScript asks a server of a different origin for data, the server must explicitly allow it, or the browser blocks the response.exampledeep dive
• Private keyThe half of a key pair that must never leave you: it stays on your machine to prove "I am who I claim", while the matching public key can be shared openly.animatedexampledeep dive

The model itself: what it eats, what it returns, and why it gets things wrong.

• LLM (Large Language Model)A neural network trained to predict the next token. It can only output text.animatedexampledeep dive
• TokenThe smallest unit of text a model handles. Not a character, and not a word.animatedexampledeep dive
• Context windowThe total tokens a model can see at once — and input and output share that budget.animatedexampledeep dive
• HallucinationThe model produces text that reads perfectly plausibly but is factually wrong or invented.exampledeep dive
• TokenizationThe rule set that chops text into tokens — and every model family chops differently.animatedexampledeep dive
• TransformerA neural-network architecture built around attention, introduced in 2017; virtually every modern LLM is built on it.animatedexampledeep dive
• PromptThe entire token sequence sent to the model this turn: system instructions, conversation history, tool definitions, retrieved material, plus the sentence you actually typed — all of it.exampledeep dive
• System promptA standing instruction written by the developer — not the user — placed at the front of the prompt to frame the model's role, tone and boundaries.exampledeep dive
• TemperatureThe knob for sampling randomness: lower values push the model toward the highest-probability token; higher values give unlikely candidates a real chance.exampledeep dive
• Top-p (nucleus sampling)The other randomness knob: rank candidate tokens by probability, keep the smallest set whose cumulative probability reaches p (say 0.9), discard the tail entirely, then sample from what remains.exampledeep dive
• InferenceRunning an already-trained model to produce output — the counterpart of training, and the entirety of the computation that happens when you use a model.animatedexampledeep dive
• Prefill and decodeThe two phases of a generation: prefill digests the entire prompt in one parallel pass (compute-bound, sets time-to-first-token); decode then emits one token at a time (memory-bandwidth-bound, sets tokens per second).animatedexampledeep dive
• Fine-tuningTaking an existing model and continuing training on your own data, writing new behaviour or style into the weights.exampledeep dive
• QuantizationStoring model weights in lower-precision numbers, trading tolerable quality loss for dramatically smaller size and memory footprint.exampledeep dive
• Model file formatHow model weights are packaged on disk: GGUF, safetensors, MLX and friends are different boxes, and each runtime only opens the ones it supports.exampledeep dive
• MultimodalA model that handles more than text (images, audio, video): non-text input is converted into representations the model can read, sharing one context with the text.exampledeep dive
• Reasoning modelA model that generates a long internal chain of thought before answering, trading extra output tokens for higher accuracy on multi-step problems.exampledeep dive
• Frontier modelThe small set of most capable models at a given moment — a moving label, not a fixed technical specification.exampledeep dive
• MoE (Mixture of Experts)An architecture that keeps many "expert" sub-networks inside but routes each token to only a few of them — huge total parameters, much smaller compute per token.exampledeep dive
• Model Provider / Provider APIA Model Provider / Provider API is the model company's service entry: your program sends messages, the provider returns results and bills by plan; it is not a coding agent.
• LLM Router / API RouterAn LLM Router / API Router works like a switchboard: one API can forward requests to different models or backends.
• Model RuntimeA Model Runtime loads a model and exposes an inference API.
• Zero-shot / One-shot / Few-shotThese names only count how many demonstrations the prompt carries: none, one, or a few.
• Pre-trainingPre-training uses massive data to teach general patterns, changing model weights and producing a base model for later adjustment.
• Post-trainingPost-training is the training stage after a Base Model is complete.
• SFT (Supervised Fine-Tuning)SFT gives the model good input-answer pairs to imitate; a common post-training method that adjusts model weights.
• DPO (Direct Preference Optimization)DPO learns preferences from pairs of a better and a worse answer; it needs trustworthy preference data and adjusts weights.
• RLHF / RLRLHF / RL trains the model with human or rule feedback; badly designed feedback can teach reward hacking, so evals still matter.
• GRPOGRPO compares several answers to the same question, then updates the model from their relative results.
• DistillationDistillation lets a smaller student model learn from a larger teacher, usually to shrink size or cost while keeping ability.

The layer of ordinary code that lets a model actually do things.

• AI agentAn LLM plus context, tools and a loop: the model decides the next step and can actually carry it out.animatedexampledeep dive
• Tool callThe model does not act; it requests action by returning structured text saying "call this tool with these arguments".animatedexampledeep dive
• HarnessThe layer of code wrapped around a model: assembling context, calling the model, parsing output, running tools, gating permissions, feeding results back.animatedexampledeep dive
• Agent loopThe agent's heartbeat: assemble context, call the model, parse its output, execute the action, feed the result back — repeat until the task is done or a stop condition fires.animatedexampledeep dive
• ReAct (Reason + Act)The model narrates a thought before each action, proposes the action, receives an observation, and repeats — reasoning and acting interleaved instead of separated.animatedexampledeep dive
• PlanningBefore acting, have the model produce a list of steps, then execute them — revising the list as reality reports back.exampledeep dive
• SubagentThe main agent hands a subtask to a separately running agent with its own clean context; when it finishes, only the result comes back.exampledeep dive
• OrchestratorThe layer that decides which task goes to whom, in what order, and how results are collected; in a lead/worker pattern, the lead that delegates rather than does.animatedexampledeep dive
• Agent memoryInformation stored outside the model — files, databases — selected and re-injected into context when needed; the model itself retains nothing across calls.animatedexampledeep dive
• SkillA packaged, reusable capability: an instruction file for one class of task, plus optional scripts and resources, loaded by the agent only when needed.exampledeep dive
• Slash commandA short /command typed by the user that expands into a predefined workflow — triggered by a human, never selected by the model.exampledeep dive
• MCP (Model Context Protocol)An open standard for exposing tools, resources and prompt templates to AI clients — write the server once, and every MCP-compatible client can use it.animatedexampledeep dive
• CheckpointA saved snapshot of a task half-finished, so work resumes from here after an interruption instead of restarting from zero.exampledeep dive
• Human-in-the-loop (HITL)A deliberately inserted point where the flow stops and waits for a human: the agent continues only after a person has looked and approved.exampledeep dive
• Multi-agent systemSeveral agents with divided responsibilities completing one task — collection, analysis and reporting split apart, joined by messages and shared state.exampledeep dive
• Tool SchemaA Tool Schema is a tool description card with its name, purpose, input fields, types, and required values.
• Tool ResultA Tool Result is what the program returns to the model after running a tool.
• Workflow GraphA workflow graph uses nodes, edges, branches, and state to make the work route explicit; a node may be an agent, a tool, a check, or a human approval.
• Self-RefineSelf-Refine has the model produce an answer, then revise it once or more from feedback, without persistent memory.
• ReflexionReflexion stores past attempts, feedback, and reflections as episodic memory for later attempts — beyond a single Self-Refine pass.
• HandoffA handoff passes a task and its necessary context from one agent to another, stating goal, progress, and boundaries.
• Project InstructionsProject Instructions are shared rules a tool reads for a project, such as purpose, prohibited actions, verification commands, and delivery format.
• One-off PromptA one-off prompt serves only the task at hand; rules that must hold every time belong in project instructions or skills.
• Plugin / MarketplaceA Plugin packages components such as Skills, commands, hooks, or MCP configuration for distribution; a Marketplace is a catalog for finding and installing those packages.
• CLAUDE.mdCLAUDE.md is one of the project instruction files Claude Code reads to learn how the project works; it is context for the model, not a permission boundary.
• HooksHooks run a fixed check or action when a selected event occurs.
• Deep AgentDeep Agent is not one formal cross-vendor standard.
• EvalAn eval compares a prompt, model, or agent with fixed inputs, success criteria, and recording.
• Case/TaskA case/task is one question on the eval exam: fixed input, test environment, and success criteria.
• SuiteA Suite is a group of cases that run together and have a version.
• Golden Set / Reference SetA golden set / reference set holds human-reviewed cases and expected standards that represent real work.
• Reference Solution / CriteriaReference solution / criteria state what counts as success; agent tasks often have several good answers, so write criteria, not a single answer.
• TrialA Trial is one complete execution of a case.
• GraderA grader judges each trial by rules; use deterministic graders for exact checks and add model graders only where quality is fuzzy.
• BaselineA baseline is the pre-change comparison point: same cases, environment, trial count, and thresholds, or scores cannot be compared.
• RegressionA regression is a decline beyond threshold versus the baseline, in quality, cost, safety, or reliability; check it before shipping.
• Holdout SetA holdout set is a frozen set of cases never used for tuning; develop on the development set and measure on the holdout.
• ObservabilityObservability leaves inspectable records of Agent steps, tools, state, timing, usage, and results.
• CLI AgentA CLI Agent is an Agent / Harness that reads files, edits files, and runs commands from a terminal.
• Context EngineeringContext Engineering decides what information enters each model call, in what order, and when it should be removed or compressed.
• Agent Production EngineeringAgent Production Engineering is this roadmap's umbrella name for making an Agent dependable, safe, and observable over time.
• Harness EngineeringHarness Engineering designs and improves an Agent Harness.
• Computer UseComputer Use lets the model read the screen and propose mouse or keyboard actions; the harness checks rules and the executor acts. It is the biggest, riskiest door.
• Browser UseBrowser Use lets an Agent read data, find elements, fill forms, or move between pages.

Where the hardware bottlenecks are, and which numbers actually matter.

• GPU (graphics processing unit)A chip built to do many simple calculations at once, which is exactly the shape of work a large model needs.animatedexampledeep dive
• VRAM (GPU memory)The GPU's own memory. Model weights and the KV cache must fit here first; if they do not, the model does not run.exampledeep dive
• FLOPS (floating-point operations per second)A raw compute number: how many floating-point operations per second. It looks the most technical, yet it predicts the speed you actually feel the worst.exampledeep dive
• Parameter countHow many adjustable numbers a model holds. It is often used as a label for "how big and smart" a model is, but that label misleads more often than you think.exampledeep dive
• Unified memory (CPU and GPU share one pool)CPU and GPU share one block of memory, with no copying between two pools. Apple Silicon is the classic example.exampledeep dive
• CPU inference (running a model without a GPU)Running a model on the CPU alone, with no GPU. For small models, low volume and offline batch work it is genuinely usable; for large models or interactive use it is essentially hopeless.exampledeep dive
• Local vs cloud (run it yourself or call an API)Whether the model runs on your own machine (local) or you call someone else's over the network (cloud API). The real difference is not "free vs paid" but several axes: privacy, cost at volume, latency, capability ceiling and maintenance burden.exampledeep dive
• TTFT (time to first token)The dead air between pressing send and the first character appearing. It is driven mainly by prompt length and prefill, and it is the number users actually experience as "lag".animatedexampledeep dive
• Tokens per second (generation throughput)How many tokens a model emits per second. During decode it is set mainly by memory bandwidth, not compute; the vendor's figure and your measured figure often differ by a wide margin.exampledeep dive
• Concurrency (how many requests at once)How many requests a system handles at the same time. How fast one user feels it is, and how many people one machine can serve at once, are two completely different problems.exampledeep dive
• Batching (serving many requests together)Running several requests together to amortize the cost of hauling weights into the compute units. It raises the machine's total throughput but can lengthen any single request's latency.exampledeep dive
• KV cacheStoring each processed token's Key and Value so the next token need not recompute them. The cost: this memory grows with sequence length, which is exactly why long context is so RAM-hungry.animatedexampledeep dive
• Cost per token (how API pricing actually works)APIs price input tokens and output tokens separately, output is usually dearer, and cached input is often discounted. An agent's bill is frightening because each turn it resends a longer and longer context.exampledeep dive
• Prompt CachingPrompt Caching reuses a previously cached, byte-identical Prompt prefix to reduce repeated processing; similar but different content is a cache miss.
• Batch APIA batch API sends many not-urgent requests together; good for offline classification, summarization, or evals — check timing, limits, and discounts.
• Token Cost / Inference CostToken cost / inference cost is input usage × input price + output usage × output price.

How outside knowledge reaches the model, and what happens when the wrong knowledge arrives.

• RAG (Retrieval-Augmented Generation)Look material up first, hand the retrieved passages to the model along with the question, and have it answer from them.animatedexampledeep dive
• EmbeddingTurning text into a list of numbers so that "similar meaning" becomes "close in distance".animatedexampledeep dive
• Vector databaseA database that searches by how close the meaning is: you give it a query vector and it returns the nearest few records, instead of matching exact wording.animatedexampledeep dive
• ChunkingBefore embedding, cut long documents into small pieces; a vector compresses the meaning of a whole passage into one point, and the longer the passage, the blurrier that point.animatedexampledeep dive
• RerankingThe second pass of retrieval: a cheap, fast method pulls a batch of candidates, then a smarter, pricier model reads the query together with each candidate to reorder them by true relevance.exampledeep dive
• Full-text searchTraditional keyword search that ranks by whether terms appear, how often, and how rare they are; the classic algorithm is BM25. It does not understand meaning — it counts words.exampledeep dive
• OCR (Optical Character Recognition)Recognising the "picture-of-text" in images, scans and PDFs into real text a computer can process; the first step for any paper document entering a data pipeline.exampledeep dive
• Structured outputAsking the model to return data that conforms to a format you specify (usually a JSON schema) instead of free prose, so downstream code can parse it directly without guessing.exampledeep dive
• Semantic vs keyword searchThe core trade-off between two retrieval styles: keyword matches on whether wording is identical, semantic on whether meaning is close. The former is precise but rigid; the latter is flexible but can miss the point.exampledeep dive
• Data pipelineA fixed chain of steps that carries data from source to usable state: ingest → clean → transform → store → serve. Almost every AI application sits on such a pipeline.exampledeep dive
• GroundingTying each claim the model makes back to a source the reader can verify themselves; not "it says it has a source" but "the source really exists and really supports this sentence".exampledeep dive
• Hybrid SearchHybrid Search combines semantic vectors and keyword signals and merges the results, balancing similar meaning with exact names.
• Contextual RetrievalContextual Retrieval prepends each chunk with brief context from its source document before indexing.

An AI that can act can also do damage. These terms are the boundary.

• Prompt injectionAn attacker hides instructions inside content the AI will read, so the AI treats data as commands.exampledeep dive
• SandboxThe fence around what an AI may touch: which folders are writable, whether it has network access, and whether it must ask you each time.animatedexampledeep dive
• JailbreakUsing conversational tricks to make a model bypass its own usage rules and output what its makers never intended.exampledeep dive
• Data classificationSorting data by sensitivity first — public, internal, confidential, restricted — then deciding where each class may flow, including whether it may enter a model's context.exampledeep dive
• PII (Personally Identifiable Information)Data that identifies a specific person, alone or in combination: names, ID numbers, phone numbers, addresses, medical records, precise location…exampledeep dive
• De-identificationRemoving or rewriting the person-pointing parts of data so it stays analysable but (ideally) no longer reveals who it is about.exampledeep dive
• Red teamingDeliberately attacking your own system from the attacker's position, to find the failures before users or real attackers do.exampledeep dive
• Supply chain riskRisk that arrives not through your own code but through what you install: dependencies, plugins, third-party skills, MCP servers.exampledeep dive
• Audit logA tamper-evident record of behaviour: when, driven by what input, the agent called which tools with which arguments and got which results — written by the execution layer, not narrated by the model.exampledeep dive
• Permission gateThe decision point before an action runs: allow, ask a human, or deny — enforced by harness code, not left to the model's goodwill.animatedexampledeep dive
• Verification gateAn independent check before a result is accepted: performed by a checker distinct from the producer — separate session, unshared context — against what was actually required.exampledeep dive
• GuardrailsGuardrails are rules that constrain inputs, outputs, and actions, such as schema validation, allowlists, permissions, and human approval.
• Lethal TrifectaThe Lethal Trifecta describes an Agent that can read private data, encounter untrusted content, and communicate outward at the same time; Prompt Injection may then exfiltrate data.
• BYO API KeyBYO API Key means the tool lets you bring your own provider key; convenient for switching, but billing, permissions, and custody stay yours.